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 SWIGJAVA
13 : #define SWIGJAVA
14 : #endif
15 :
16 :
17 :
18 : #ifdef __cplusplus
19 : /* SwigValueWrapper is described in swig.swg */
20 : template<typename T> class SwigValueWrapper {
21 : struct SwigMovePointer {
22 : T *ptr;
23 : SwigMovePointer(T *p) : ptr(p) { }
24 : ~SwigMovePointer() { delete ptr; }
25 : SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
26 : } pointer;
27 : SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
28 : SwigValueWrapper(const SwigValueWrapper<T>& rhs);
29 : public:
30 : SwigValueWrapper() : pointer(0) { }
31 : SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
32 : operator T&() const { return *pointer.ptr; }
33 : T *operator&() { return pointer.ptr; }
34 : };
35 :
36 : template <typename T> T SwigValueInit() {
37 : return T();
38 : }
39 : #endif
40 :
41 : /* -----------------------------------------------------------------------------
42 : * This section contains generic SWIG labels for method/variable
43 : * declarations/attributes, and other compiler dependent labels.
44 : * ----------------------------------------------------------------------------- */
45 :
46 : /* template workaround for compilers that cannot correctly implement the C++ standard */
47 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
48 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
49 : # define SWIGTEMPLATEDISAMBIGUATOR template
50 : # elif defined(__HP_aCC)
51 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
52 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
53 : # define SWIGTEMPLATEDISAMBIGUATOR template
54 : # else
55 : # define SWIGTEMPLATEDISAMBIGUATOR
56 : # endif
57 : #endif
58 :
59 : /* inline attribute */
60 : #ifndef SWIGINLINE
61 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
62 : # define SWIGINLINE inline
63 : # else
64 : # define SWIGINLINE
65 : # endif
66 : #endif
67 :
68 : /* attribute recognised by some compilers to avoid 'unused' warnings */
69 : #ifndef SWIGUNUSED
70 : # if defined(__GNUC__)
71 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
72 : # define SWIGUNUSED __attribute__ ((__unused__))
73 : # else
74 : # define SWIGUNUSED
75 : # endif
76 : # elif defined(__ICC)
77 : # define SWIGUNUSED __attribute__ ((__unused__))
78 : # else
79 : # define SWIGUNUSED
80 : # endif
81 : #endif
82 :
83 : #ifndef SWIG_MSC_UNSUPPRESS_4505
84 : # if defined(_MSC_VER)
85 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
86 : # endif
87 : #endif
88 :
89 : #ifndef SWIGUNUSEDPARM
90 : # ifdef __cplusplus
91 : # define SWIGUNUSEDPARM(p)
92 : # else
93 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
94 : # endif
95 : #endif
96 :
97 : /* internal SWIG method */
98 : #ifndef SWIGINTERN
99 : # define SWIGINTERN static SWIGUNUSED
100 : #endif
101 :
102 : /* internal inline SWIG method */
103 : #ifndef SWIGINTERNINLINE
104 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
105 : #endif
106 :
107 : /* exporting methods */
108 : #if defined(__GNUC__)
109 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
110 : # ifndef GCC_HASCLASSVISIBILITY
111 : # define GCC_HASCLASSVISIBILITY
112 : # endif
113 : # endif
114 : #endif
115 :
116 : #ifndef SWIGEXPORT
117 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
118 : # if defined(STATIC_LINKED)
119 : # define SWIGEXPORT
120 : # else
121 : # define SWIGEXPORT __declspec(dllexport)
122 : # endif
123 : # else
124 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
125 : # define SWIGEXPORT __attribute__ ((visibility("default")))
126 : # else
127 : # define SWIGEXPORT
128 : # endif
129 : # endif
130 : #endif
131 :
132 : /* calling conventions for Windows */
133 : #ifndef SWIGSTDCALL
134 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
135 : # define SWIGSTDCALL __stdcall
136 : # else
137 : # define SWIGSTDCALL
138 : # endif
139 : #endif
140 :
141 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
142 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
143 : # define _CRT_SECURE_NO_DEPRECATE
144 : #endif
145 :
146 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
147 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
148 : # define _SCL_SECURE_NO_DEPRECATE
149 : #endif
150 :
151 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
152 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
153 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
154 : #endif
155 :
156 : /* Intel's compiler complains if a variable which was never initialised is
157 : * cast to void, which is a common idiom which we use to indicate that we
158 : * are aware a variable isn't used. So we just silence that warning.
159 : * See: https://github.com/swig/swig/issues/192 for more discussion.
160 : */
161 : #ifdef __INTEL_COMPILER
162 : # pragma warning disable 592
163 : #endif
164 :
165 :
166 : /* Fix for jlong on some versions of gcc on Windows */
167 : #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
168 : typedef long long __int64;
169 : #endif
170 :
171 : /* Fix for jlong on 64-bit x86 Solaris */
172 : #if defined(__x86_64)
173 : # ifdef _LP64
174 : # undef _LP64
175 : # endif
176 : #endif
177 :
178 : #include <jni.h>
179 : #include <stdlib.h>
180 : #include <string.h>
181 :
182 :
183 : /* Support for throwing Java exceptions */
184 : typedef enum {
185 : SWIG_JavaOutOfMemoryError = 1,
186 : SWIG_JavaIOException,
187 : SWIG_JavaRuntimeException,
188 : SWIG_JavaIndexOutOfBoundsException,
189 : SWIG_JavaArithmeticException,
190 : SWIG_JavaIllegalArgumentException,
191 : SWIG_JavaNullPointerException,
192 : SWIG_JavaDirectorPureVirtual,
193 : SWIG_JavaUnknownError,
194 : SWIG_JavaIllegalStateException,
195 : } SWIG_JavaExceptionCodes;
196 :
197 : typedef struct {
198 : SWIG_JavaExceptionCodes code;
199 : const char *java_exception;
200 : } SWIG_JavaExceptions_t;
201 :
202 :
203 0 : static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
204 : jclass excep;
205 : static const SWIG_JavaExceptions_t java_exceptions[] = {
206 : { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
207 : { SWIG_JavaIOException, "java/io/IOException" },
208 : { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
209 : { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
210 : { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
211 : { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
212 : { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
213 : { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
214 : { SWIG_JavaUnknownError, "java/lang/UnknownError" },
215 : { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" },
216 : { (SWIG_JavaExceptionCodes)0, "java/lang/UnknownError" }
217 : };
218 0 : const SWIG_JavaExceptions_t *except_ptr = java_exceptions;
219 :
220 0 : while (except_ptr->code != code && except_ptr->code)
221 0 : except_ptr++;
222 :
223 0 : jenv->ExceptionClear();
224 0 : excep = jenv->FindClass(except_ptr->java_exception);
225 0 : if (excep)
226 0 : jenv->ThrowNew(excep, msg);
227 0 : }
228 :
229 :
230 : /* Contract support */
231 :
232 : #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else
233 :
234 : /* Errors in SWIG */
235 : #define SWIG_UnknownError -1
236 : #define SWIG_IOError -2
237 : #define SWIG_RuntimeError -3
238 : #define SWIG_IndexError -4
239 : #define SWIG_TypeError -5
240 : #define SWIG_DivisionByZero -6
241 : #define SWIG_OverflowError -7
242 : #define SWIG_SyntaxError -8
243 : #define SWIG_ValueError -9
244 : #define SWIG_SystemError -10
245 : #define SWIG_AttributeError -11
246 : #define SWIG_MemoryError -12
247 : #define SWIG_NullReferenceError -13
248 :
249 :
250 :
251 :
252 0 : SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
253 0 : SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
254 0 : switch(code) {
255 0 : case SWIG_MemoryError:
256 0 : exception_code = SWIG_JavaOutOfMemoryError;
257 0 : break;
258 0 : case SWIG_IOError:
259 0 : exception_code = SWIG_JavaIOException;
260 0 : break;
261 0 : case SWIG_SystemError:
262 : case SWIG_RuntimeError:
263 0 : exception_code = SWIG_JavaRuntimeException;
264 0 : break;
265 0 : case SWIG_OverflowError:
266 : case SWIG_IndexError:
267 0 : exception_code = SWIG_JavaIndexOutOfBoundsException;
268 0 : break;
269 0 : case SWIG_DivisionByZero:
270 0 : exception_code = SWIG_JavaArithmeticException;
271 0 : break;
272 0 : case SWIG_SyntaxError:
273 : case SWIG_ValueError:
274 : case SWIG_TypeError:
275 0 : exception_code = SWIG_JavaIllegalArgumentException;
276 0 : break;
277 0 : case SWIG_UnknownError:
278 : default:
279 0 : exception_code = SWIG_JavaUnknownError;
280 0 : break;
281 : }
282 0 : SWIG_JavaThrowException(jenv, exception_code, msg);
283 0 : }
284 :
285 :
286 : #include <typeinfo>
287 : #include <stdexcept>
288 :
289 :
290 : #include <iostream>
291 : #include <vector>
292 : using namespace std;
293 :
294 : #define CPL_SUPRESS_CPLUSPLUS
295 :
296 : // Suppress deprecation warning for GDALApplyVerticalShiftGrid
297 : #define CPL_WARN_DEPRECATED_GDALApplyVerticalShiftGrid(x)
298 :
299 : #include "cpl_port.h"
300 : #include "cpl_string.h"
301 : #include "cpl_multiproc.h"
302 : #include "cpl_http.h"
303 : #include "cpl_vsi_error.h"
304 :
305 : #include "gdal.h"
306 : #include "gdal_alg.h"
307 : #include "gdalwarper.h"
308 : #include "ogr_srs_api.h"
309 :
310 : // From gdal_priv.h
311 : void CPL_DLL GDALEnablePixelTypeSignedByteWarning(GDALRasterBandH hBand, bool b);
312 :
313 : typedef void GDALMajorObjectShadow;
314 : typedef void GDALDriverShadow;
315 : typedef void GDALDatasetShadow;
316 : typedef void GDALRasterBandShadow;
317 : typedef void GDALColorTableShadow;
318 : typedef void GDALRasterAttributeTableShadow;
319 : typedef void GDALSubdatasetInfoShadow;
320 : typedef void GDALTransformerInfoShadow;
321 : typedef void GDALAsyncReaderShadow;
322 : typedef void GDALRelationshipShadow;
323 :
324 : typedef GDALExtendedDataTypeHS GDALExtendedDataTypeHS;
325 : typedef GDALEDTComponentHS GDALEDTComponentHS;
326 : typedef GDALGroupHS GDALGroupHS;
327 : typedef GDALMDArrayHS GDALMDArrayHS;
328 : typedef GDALAttributeHS GDALAttributeHS;
329 : typedef GDALDimensionHS GDALDimensionHS;
330 :
331 :
332 :
333 : #ifdef DEBUG
334 : typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
335 : typedef struct OGRLayerHS OGRLayerShadow;
336 : typedef struct OGRFeatureHS OGRFeatureShadow;
337 : typedef struct OGRGeometryHS OGRGeometryShadow;
338 : #else
339 : typedef void OSRSpatialReferenceShadow;
340 : typedef void OGRLayerShadow;
341 : typedef void OGRFeatureShadow;
342 : typedef void OGRGeometryShadow;
343 : #endif
344 :
345 : typedef struct OGRStyleTableHS OGRStyleTableShadow;
346 : typedef struct OGRFieldDomainHS OGRFieldDomainShadow;
347 : typedef struct OGRGeomFieldDefnHS OGRGeomFieldDefnShadow;
348 :
349 :
350 : /* use this to not return the int returned by GDAL */
351 : typedef int RETURN_NONE;
352 : /* return value that is used for VSI methods that return -1 on error (and set errno) */
353 : typedef int VSI_RETVAL;
354 :
355 :
356 : static int bUseExceptions=1;
357 :
358 : static void CPL_STDCALL
359 0 : VeryQuietErrorHandler(CPLErr eclass, int code, const char *msg )
360 : {
361 : /* If the error class is CE_Fatal, we want to have a message issued
362 : because the CPL support code does an abort() before any exception
363 : can be generated */
364 0 : if (eclass == CE_Fatal ) {
365 0 : CPLDefaultErrorHandler(eclass, code, msg );
366 : }
367 0 : }
368 :
369 :
370 0 : static void UseExceptions() {
371 0 : bUseExceptions = 1;
372 0 : CPLSetErrorHandler( (CPLErrorHandler) VeryQuietErrorHandler );
373 0 : }
374 :
375 0 : static void DontUseExceptions() {
376 0 : bUseExceptions = 0;
377 0 : CPLSetErrorHandler( CPLDefaultErrorHandler );
378 0 : }
379 :
380 0 : static bool GetUseExceptions() {
381 0 : return bUseExceptions == 1;
382 : }
383 :
384 :
385 :
386 20 : static GDALDimensionH GDALMDArrayGetDim(GDALMDArrayH hMDA, size_t index) {
387 :
388 : size_t dimCount;
389 :
390 20 : GDALDimensionH* dims = GDALMDArrayGetDimensions(hMDA, &dimCount);
391 :
392 : GDALDimensionH retVal;
393 :
394 20 : if (index < 0 || index >= dimCount) {
395 :
396 0 : retVal = NULL;
397 : }
398 : else {
399 :
400 20 : retVal = dims[index];
401 :
402 20 : dims[index] = NULL; // make sure we do not free our index
403 : }
404 :
405 : // free all the other indices
406 :
407 20 : GDALReleaseDimensions(dims, dimCount);
408 :
409 20 : return retVal;
410 : }
411 :
412 18 : static bool MDArrayRead(GDALMDArrayH hMDA,
413 : int numDims,
414 : const GInt64 *arrayStartIdxes,
415 : const GInt64 *counts,
416 : const GInt64 *arraySteps,
417 : GInt64 *bufferStrides,
418 : void* arrayOut,
419 : size_t arrayByteSize,
420 : GDALExtendedDataTypeH data_type)
421 : {
422 : size_t* localCounts =
423 18 : (size_t*) malloc(sizeof(size_t) * numDims);
424 :
425 : GPtrDiff_t* localBufferStrides =
426 18 : (GPtrDiff_t*) malloc(sizeof(GPtrDiff_t) * numDims);
427 :
428 83 : for (int i = 0; i < numDims; i++) {
429 65 : localCounts[i] = (size_t) counts[i];
430 65 : localBufferStrides[i] = (GPtrDiff_t) bufferStrides[i];
431 : }
432 :
433 18 : bool retVal = GDALMDArrayRead(hMDA,
434 : (const GUInt64*) arrayStartIdxes,
435 : localCounts,
436 : arraySteps,
437 : localBufferStrides,
438 : data_type,
439 : arrayOut,
440 : arrayOut,
441 18 : arrayByteSize);
442 :
443 18 : free(localBufferStrides);
444 18 : free(localCounts);
445 :
446 18 : return retVal;
447 : }
448 :
449 18 : static bool MDArrayWrite(GDALMDArrayH hMDA,
450 : int numDims,
451 : const GInt64 *arrayStartIdxes,
452 : const GInt64 *counts,
453 : const GInt64 *arraySteps,
454 : GInt64 *bufferStrides,
455 : void* arrayIn,
456 : size_t arrayByteSize,
457 : GDALExtendedDataTypeH data_type)
458 : {
459 : size_t* localCounts =
460 18 : (size_t*) malloc(sizeof(size_t) * numDims);
461 :
462 : GPtrDiff_t* localBufferStrides =
463 18 : (GPtrDiff_t*) malloc(sizeof(GPtrDiff_t) * numDims);
464 :
465 83 : for (int i = 0; i < numDims; i++) {
466 65 : localCounts[i] = (size_t) counts[i];
467 65 : localBufferStrides[i] = (GPtrDiff_t) bufferStrides[i];
468 : }
469 :
470 18 : bool retVal = GDALMDArrayWrite(hMDA,
471 : (const GUInt64*) arrayStartIdxes,
472 : localCounts,
473 : arraySteps,
474 : localBufferStrides,
475 : data_type,
476 : arrayIn,
477 : arrayIn,
478 18 : arrayByteSize);
479 :
480 18 : free(localBufferStrides);
481 18 : free(localCounts);
482 :
483 18 : return retVal;
484 : }
485 :
486 :
487 :
488 0 : static CPLErr BandBlockReadWrite_Validate(GDALRasterBandH self, void *nioBuffer, size_t nioBufferSize)
489 : {
490 : int nBlockXSize, nBlockYSize;
491 : GDALDataType eDataType;
492 0 : GDALGetBlockSize(self, &nBlockXSize, &nBlockYSize);
493 0 : eDataType = GDALGetRasterDataType(self);
494 0 : int nDataTypeSize = GDALGetDataTypeSize( eDataType ) / 8;
495 0 : if (nBlockXSize > (INT_MAX / nDataTypeSize) / nBlockYSize)
496 : {
497 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
498 0 : return CE_Failure;
499 : }
500 0 : if (nioBufferSize < (size_t)nBlockXSize * nBlockYSize * nDataTypeSize)
501 : {
502 0 : CPLError(CE_Failure, CPLE_AppDefined, "Buffer not big enough");
503 0 : return CE_Failure;
504 : }
505 0 : return CE_None;
506 : }
507 :
508 :
509 :
510 : static
511 : GIntBig ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
512 : int nBands, int* bandMap, int nBandMapArrayLength,
513 : GIntBig nPixelSpace, GIntBig nLineSpace, GIntBig nBandSpace,
514 : int bSpacingShouldBeMultipleOfPixelSize );
515 :
516 2 : static CPLErr DatasetRasterIO( GDALDatasetH hDS, GDALRWFlag eRWFlag,
517 : int xoff, int yoff, int xsize, int ysize,
518 : int buf_xsize, int buf_ysize,
519 : GDALDataType buf_type,
520 : void *regularArray, size_t nRegularArraySize,
521 : int band_list, int *pband_list,
522 : int nPixelSpace, int nLineSpace, int nBandSpace,
523 : GDALDataType gdal_type, size_t sizeof_ctype)
524 : {
525 2 : if ((gdal_type == GDT_Int16 && buf_type != GDT_Int16 && buf_type != GDT_UInt16 && buf_type != GDT_CInt16) ||
526 2 : (gdal_type == GDT_Int32 && buf_type != GDT_Int32 && buf_type != GDT_UInt32 && buf_type != GDT_CInt32) ||
527 2 : (gdal_type == GDT_Int64 && buf_type != GDT_Int64 && buf_type != GDT_UInt64) ||
528 2 : (gdal_type == GDT_Float32 && buf_type != GDT_Float32 && buf_type != GDT_CFloat32) ||
529 0 : (gdal_type == GDT_Float64 && buf_type != GDT_Float64 && buf_type != GDT_CFloat64))
530 : {
531 0 : CPLError(CE_Failure, CPLE_AppDefined,
532 : "Java array type is not compatible with GDAL data type");
533 0 : return CE_Failure;
534 : }
535 :
536 2 : if (band_list == 0)
537 : {
538 0 : if (pband_list != NULL)
539 0 : return CE_Failure;
540 :
541 0 : band_list = GDALGetRasterCount(hDS);
542 : }
543 :
544 6 : GIntBig nMinBufferSizeInBytes = ComputeDatasetRasterIOSize (
545 2 : buf_xsize, buf_ysize, GDALGetDataTypeSize(buf_type) / 8,
546 : band_list, pband_list, band_list,
547 : nPixelSpace, nLineSpace, nBandSpace, sizeof_ctype > 1 );
548 :
549 2 : if (nMinBufferSizeInBytes > 0x7fffffff)
550 : {
551 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
552 0 : nMinBufferSizeInBytes = 0;
553 : }
554 :
555 2 : if (nMinBufferSizeInBytes == 0)
556 0 : return CE_Failure;
557 :
558 2 : if (nRegularArraySize < nMinBufferSizeInBytes)
559 : {
560 0 : CPLError(CE_Failure, CPLE_AppDefined,
561 : "Buffer is too small");
562 0 : return CE_Failure;
563 : }
564 :
565 2 : return GDALDatasetRasterIO( hDS, eRWFlag, xoff, yoff, xsize, ysize,
566 : regularArray, buf_xsize, buf_ysize,
567 2 : buf_type, band_list, pband_list, nPixelSpace, nLineSpace, nBandSpace );
568 : }
569 :
570 :
571 :
572 : static
573 : GIntBig ComputeBandRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
574 : GIntBig nPixelSpace, GIntBig nLineSpace,
575 : int bSpacingShouldBeMultipleOfPixelSize );
576 :
577 79994 : static CPLErr BandRasterIO( GDALRasterBandH hBand, GDALRWFlag eRWFlag,
578 : int xoff, int yoff, int xsize, int ysize,
579 : int buf_xsize, int buf_ysize,
580 : GDALDataType buf_type,
581 : void *regularArrayOut, size_t nRegularArraySizeOut,
582 : int nPixelSpace, int nLineSpace,
583 : GDALDataType gdal_type, size_t sizeof_ctype)
584 : {
585 79994 : if ((gdal_type == GDT_Int16 && buf_type != GDT_Int16 && buf_type != GDT_UInt16 && buf_type != GDT_CInt16) ||
586 79994 : (gdal_type == GDT_Int32 && buf_type != GDT_Int32 && buf_type != GDT_UInt32 && buf_type != GDT_CInt32) ||
587 79994 : (gdal_type == GDT_Int64 && buf_type != GDT_Int64 && buf_type != GDT_UInt64) ||
588 79994 : (gdal_type == GDT_Float32 && buf_type != GDT_Float32 && buf_type != GDT_CFloat32) ||
589 0 : (gdal_type == GDT_Float64 && buf_type != GDT_Float64 && buf_type != GDT_CFloat64))
590 : {
591 0 : CPLError(CE_Failure, CPLE_AppDefined,
592 : "Java array type is not compatible with GDAL data type");
593 0 : return CE_Failure;
594 : }
595 :
596 239928 : GIntBig nMinBufferSizeInBytes = ComputeBandRasterIOSize (
597 79994 : buf_xsize, buf_ysize, GDALGetDataTypeSize(buf_type) / 8,
598 : nPixelSpace, nLineSpace, sizeof_ctype > 1 );
599 79966 : if (nMinBufferSizeInBytes > 0x7fffffff)
600 : {
601 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
602 0 : nMinBufferSizeInBytes = 0;
603 : }
604 79966 : if (nMinBufferSizeInBytes == 0)
605 0 : return CE_Failure;
606 79966 : if (nRegularArraySizeOut < nMinBufferSizeInBytes)
607 : {
608 0 : CPLError(CE_Failure, CPLE_AppDefined,
609 : "Buffer is too small");
610 0 : return CE_Failure;
611 : }
612 :
613 79966 : return GDALRasterIO( hBand, eRWFlag, xoff, yoff, xsize, ysize,
614 : regularArrayOut, buf_xsize, buf_ysize,
615 79985 : buf_type, nPixelSpace, nLineSpace );
616 : }
617 :
618 :
619 :
620 0 : static size_t GDALAttributeGetDimSize(GDALAttributeH attH, size_t index) {
621 :
622 : size_t size;
623 :
624 : size_t count;
625 :
626 0 : GUInt64* sizes = GDALAttributeGetDimensionsSize(attH, &count);
627 :
628 0 : if (index < 0 || index >= count) {
629 :
630 0 : size = (size_t) 0;
631 : }
632 : else {
633 :
634 0 : size = (size_t) sizes[index];
635 : }
636 :
637 0 : CPLFree(sizes);
638 :
639 0 : return size;
640 : }
641 :
642 :
643 :
644 : typedef struct {
645 : JNIEnv *jenv;
646 : jobject pJavaCallback;
647 : } JavaProgressData;
648 :
649 :
650 : class ProgressCallback
651 : {
652 : public:
653 0 : virtual ~ProgressCallback() { }
654 21 : virtual int run(double dfComplete, const char* pszMessage)
655 : {
656 21 : return 1;
657 : }
658 : };
659 :
660 : class TermProgressCallback : public ProgressCallback
661 : {
662 : public:
663 2 : TermProgressCallback()
664 2 : {
665 2 : }
666 :
667 15 : virtual int run(double dfComplete, const char* pszMessage)
668 : {
669 15 : return GDALTermProgress(dfComplete, pszMessage, NULL);
670 : }
671 : };
672 :
673 :
674 : /************************************************************************/
675 : /* JavaProgressProxy() */
676 : /************************************************************************/
677 :
678 : static int CPL_STDCALL
679 26 : JavaProgressProxy( double dfComplete, const char *pszMessage, void *pData )
680 : {
681 26 : JavaProgressData* psProgressInfo = (JavaProgressData*)pData;
682 26 : JNIEnv *jenv = psProgressInfo->jenv;
683 : int ret;
684 26 : const jclass progressCallbackClass = jenv->FindClass("org/gdal/gdal/ProgressCallback");
685 26 : const jmethodID runMethod = jenv->GetMethodID(progressCallbackClass, "run", "(DLjava/lang/String;)I");
686 26 : jstring temp_string = jenv->NewStringUTF(pszMessage);
687 26 : ret = jenv->CallIntMethod(psProgressInfo->pJavaCallback, runMethod, dfComplete, temp_string);
688 26 : jenv->DeleteLocalRef(temp_string);
689 26 : return ret;
690 : }
691 :
692 :
693 : #if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)
694 :
695 :
696 : static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input);
697 : static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input);
698 : static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz);
699 :
700 :
701 : static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
702 : static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
703 : static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);
704 :
705 :
706 : static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
707 : static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
708 : static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);
709 :
710 :
711 : static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
712 : static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
713 : static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);
714 :
715 :
716 : static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
717 : static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
718 : static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);
719 :
720 :
721 : static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
722 : static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
723 : static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);
724 :
725 :
726 : static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
727 : static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
728 : static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);
729 :
730 :
731 : static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
732 : static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
733 : static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);
734 :
735 :
736 : static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
737 : static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
738 : static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);
739 :
740 :
741 : static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
742 : static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
743 : static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);
744 :
745 :
746 : static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
747 : static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
748 : static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);
749 :
750 :
751 : static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
752 : static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
753 : static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);
754 :
755 :
756 : #else
757 :
758 :
759 : /* bool[] support */
760 0 : static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) {
761 : int i;
762 : jsize sz;
763 0 : if (!input) {
764 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
765 0 : return 0;
766 : }
767 0 : sz = jenv->GetArrayLength(input);
768 0 : *jarr = jenv->GetBooleanArrayElements(input, 0);
769 0 : if (!*jarr)
770 0 : return 0;
771 0 : *carr = new bool[sz];
772 0 : if (!*carr) {
773 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
774 0 : return 0;
775 : }
776 0 : for (i=0; i<sz; i++)
777 0 : (*carr)[i] = ((*jarr)[i] != 0);
778 0 : return 1;
779 : }
780 :
781 0 : static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input) {
782 : int i;
783 0 : jsize sz = jenv->GetArrayLength(input);
784 0 : for (i=0; i<sz; i++)
785 0 : jarr[i] = (jboolean)carr[i];
786 0 : jenv->ReleaseBooleanArrayElements(input, jarr, 0);
787 0 : }
788 :
789 0 : static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) {
790 : jboolean *arr;
791 : int i;
792 0 : jbooleanArray jresult = jenv->NewBooleanArray(sz);
793 0 : if (!jresult)
794 0 : return NULL;
795 0 : arr = jenv->GetBooleanArrayElements(jresult, 0);
796 0 : if (!arr)
797 0 : return NULL;
798 0 : for (i=0; i<sz; i++)
799 0 : arr[i] = (jboolean)result[i];
800 0 : jenv->ReleaseBooleanArrayElements(jresult, arr, 0);
801 0 : return jresult;
802 : }
803 :
804 :
805 : /* signed char[] support */
806 0 : static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
807 : int i;
808 : jsize sz;
809 0 : if (!input) {
810 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
811 0 : return 0;
812 : }
813 0 : sz = jenv->GetArrayLength(input);
814 0 : *jarr = jenv->GetByteArrayElements(input, 0);
815 0 : if (!*jarr)
816 0 : return 0;
817 0 : *carr = new signed char[sz];
818 0 : if (!*carr) {
819 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
820 0 : return 0;
821 : }
822 0 : for (i=0; i<sz; i++)
823 0 : (*carr)[i] = (signed char)(*jarr)[i];
824 0 : return 1;
825 : }
826 :
827 0 : static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
828 : int i;
829 0 : jsize sz = jenv->GetArrayLength(input);
830 0 : for (i=0; i<sz; i++)
831 0 : jarr[i] = (jbyte)carr[i];
832 0 : jenv->ReleaseByteArrayElements(input, jarr, 0);
833 0 : }
834 :
835 0 : static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
836 : jbyte *arr;
837 : int i;
838 0 : jbyteArray jresult = jenv->NewByteArray(sz);
839 0 : if (!jresult)
840 0 : return NULL;
841 0 : arr = jenv->GetByteArrayElements(jresult, 0);
842 0 : if (!arr)
843 0 : return NULL;
844 0 : for (i=0; i<sz; i++)
845 0 : arr[i] = (jbyte)result[i];
846 0 : jenv->ReleaseByteArrayElements(jresult, arr, 0);
847 0 : return jresult;
848 : }
849 :
850 :
851 : /* unsigned char[] support */
852 0 : static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
853 : int i;
854 : jsize sz;
855 0 : if (!input) {
856 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
857 0 : return 0;
858 : }
859 0 : sz = jenv->GetArrayLength(input);
860 0 : *jarr = jenv->GetShortArrayElements(input, 0);
861 0 : if (!*jarr)
862 0 : return 0;
863 0 : *carr = new unsigned char[sz];
864 0 : if (!*carr) {
865 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
866 0 : return 0;
867 : }
868 0 : for (i=0; i<sz; i++)
869 0 : (*carr)[i] = (unsigned char)(*jarr)[i];
870 0 : return 1;
871 : }
872 :
873 0 : static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
874 : int i;
875 0 : jsize sz = jenv->GetArrayLength(input);
876 0 : for (i=0; i<sz; i++)
877 0 : jarr[i] = (jshort)carr[i];
878 0 : jenv->ReleaseShortArrayElements(input, jarr, 0);
879 0 : }
880 :
881 0 : static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
882 : jshort *arr;
883 : int i;
884 0 : jshortArray jresult = jenv->NewShortArray(sz);
885 0 : if (!jresult)
886 0 : return NULL;
887 0 : arr = jenv->GetShortArrayElements(jresult, 0);
888 0 : if (!arr)
889 0 : return NULL;
890 0 : for (i=0; i<sz; i++)
891 0 : arr[i] = (jshort)result[i];
892 0 : jenv->ReleaseShortArrayElements(jresult, arr, 0);
893 0 : return jresult;
894 : }
895 :
896 :
897 : /* short[] support */
898 0 : static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
899 : int i;
900 : jsize sz;
901 0 : if (!input) {
902 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
903 0 : return 0;
904 : }
905 0 : sz = jenv->GetArrayLength(input);
906 0 : *jarr = jenv->GetShortArrayElements(input, 0);
907 0 : if (!*jarr)
908 0 : return 0;
909 0 : *carr = new short[sz];
910 0 : if (!*carr) {
911 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
912 0 : return 0;
913 : }
914 0 : for (i=0; i<sz; i++)
915 0 : (*carr)[i] = (short)(*jarr)[i];
916 0 : return 1;
917 : }
918 :
919 0 : static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
920 : int i;
921 0 : jsize sz = jenv->GetArrayLength(input);
922 0 : for (i=0; i<sz; i++)
923 0 : jarr[i] = (jshort)carr[i];
924 0 : jenv->ReleaseShortArrayElements(input, jarr, 0);
925 0 : }
926 :
927 0 : static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
928 : jshort *arr;
929 : int i;
930 0 : jshortArray jresult = jenv->NewShortArray(sz);
931 0 : if (!jresult)
932 0 : return NULL;
933 0 : arr = jenv->GetShortArrayElements(jresult, 0);
934 0 : if (!arr)
935 0 : return NULL;
936 0 : for (i=0; i<sz; i++)
937 0 : arr[i] = (jshort)result[i];
938 0 : jenv->ReleaseShortArrayElements(jresult, arr, 0);
939 0 : return jresult;
940 : }
941 :
942 :
943 : /* unsigned short[] support */
944 0 : static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
945 : int i;
946 : jsize sz;
947 0 : if (!input) {
948 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
949 0 : return 0;
950 : }
951 0 : sz = jenv->GetArrayLength(input);
952 0 : *jarr = jenv->GetIntArrayElements(input, 0);
953 0 : if (!*jarr)
954 0 : return 0;
955 0 : *carr = new unsigned short[sz];
956 0 : if (!*carr) {
957 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
958 0 : return 0;
959 : }
960 0 : for (i=0; i<sz; i++)
961 0 : (*carr)[i] = (unsigned short)(*jarr)[i];
962 0 : return 1;
963 : }
964 :
965 0 : static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
966 : int i;
967 0 : jsize sz = jenv->GetArrayLength(input);
968 0 : for (i=0; i<sz; i++)
969 0 : jarr[i] = (jint)carr[i];
970 0 : jenv->ReleaseIntArrayElements(input, jarr, 0);
971 0 : }
972 :
973 0 : static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
974 : jint *arr;
975 : int i;
976 0 : jintArray jresult = jenv->NewIntArray(sz);
977 0 : if (!jresult)
978 0 : return NULL;
979 0 : arr = jenv->GetIntArrayElements(jresult, 0);
980 0 : if (!arr)
981 0 : return NULL;
982 0 : for (i=0; i<sz; i++)
983 0 : arr[i] = (jint)result[i];
984 0 : jenv->ReleaseIntArrayElements(jresult, arr, 0);
985 0 : return jresult;
986 : }
987 :
988 :
989 : /* int[] support */
990 0 : static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
991 : int i;
992 : jsize sz;
993 0 : if (!input) {
994 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
995 0 : return 0;
996 : }
997 0 : sz = jenv->GetArrayLength(input);
998 0 : *jarr = jenv->GetIntArrayElements(input, 0);
999 0 : if (!*jarr)
1000 0 : return 0;
1001 0 : *carr = new int[sz];
1002 0 : if (!*carr) {
1003 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1004 0 : return 0;
1005 : }
1006 0 : for (i=0; i<sz; i++)
1007 0 : (*carr)[i] = (int)(*jarr)[i];
1008 0 : return 1;
1009 : }
1010 :
1011 0 : static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
1012 : int i;
1013 0 : jsize sz = jenv->GetArrayLength(input);
1014 0 : for (i=0; i<sz; i++)
1015 0 : jarr[i] = (jint)carr[i];
1016 0 : jenv->ReleaseIntArrayElements(input, jarr, 0);
1017 0 : }
1018 :
1019 0 : static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
1020 : jint *arr;
1021 : int i;
1022 0 : jintArray jresult = jenv->NewIntArray(sz);
1023 0 : if (!jresult)
1024 0 : return NULL;
1025 0 : arr = jenv->GetIntArrayElements(jresult, 0);
1026 0 : if (!arr)
1027 0 : return NULL;
1028 0 : for (i=0; i<sz; i++)
1029 0 : arr[i] = (jint)result[i];
1030 0 : jenv->ReleaseIntArrayElements(jresult, arr, 0);
1031 0 : return jresult;
1032 : }
1033 :
1034 :
1035 : /* unsigned int[] support */
1036 0 : static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
1037 : int i;
1038 : jsize sz;
1039 0 : if (!input) {
1040 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1041 0 : return 0;
1042 : }
1043 0 : sz = jenv->GetArrayLength(input);
1044 0 : *jarr = jenv->GetLongArrayElements(input, 0);
1045 0 : if (!*jarr)
1046 0 : return 0;
1047 0 : *carr = new unsigned int[sz];
1048 0 : if (!*carr) {
1049 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1050 0 : return 0;
1051 : }
1052 0 : for (i=0; i<sz; i++)
1053 0 : (*carr)[i] = (unsigned int)(*jarr)[i];
1054 0 : return 1;
1055 : }
1056 :
1057 0 : static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
1058 : int i;
1059 0 : jsize sz = jenv->GetArrayLength(input);
1060 0 : for (i=0; i<sz; i++)
1061 0 : jarr[i] = (jlong)carr[i];
1062 0 : jenv->ReleaseLongArrayElements(input, jarr, 0);
1063 0 : }
1064 :
1065 0 : static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
1066 : jlong *arr;
1067 : int i;
1068 0 : jlongArray jresult = jenv->NewLongArray(sz);
1069 0 : if (!jresult)
1070 0 : return NULL;
1071 0 : arr = jenv->GetLongArrayElements(jresult, 0);
1072 0 : if (!arr)
1073 0 : return NULL;
1074 0 : for (i=0; i<sz; i++)
1075 0 : arr[i] = (jlong)result[i];
1076 0 : jenv->ReleaseLongArrayElements(jresult, arr, 0);
1077 0 : return jresult;
1078 : }
1079 :
1080 :
1081 : /* long[] support */
1082 0 : static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
1083 : int i;
1084 : jsize sz;
1085 0 : if (!input) {
1086 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1087 0 : return 0;
1088 : }
1089 0 : sz = jenv->GetArrayLength(input);
1090 0 : *jarr = jenv->GetIntArrayElements(input, 0);
1091 0 : if (!*jarr)
1092 0 : return 0;
1093 0 : *carr = new long[sz];
1094 0 : if (!*carr) {
1095 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1096 0 : return 0;
1097 : }
1098 0 : for (i=0; i<sz; i++)
1099 0 : (*carr)[i] = (long)(*jarr)[i];
1100 0 : return 1;
1101 : }
1102 :
1103 0 : static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
1104 : int i;
1105 0 : jsize sz = jenv->GetArrayLength(input);
1106 0 : for (i=0; i<sz; i++)
1107 0 : jarr[i] = (jint)carr[i];
1108 0 : jenv->ReleaseIntArrayElements(input, jarr, 0);
1109 0 : }
1110 :
1111 0 : static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
1112 : jint *arr;
1113 : int i;
1114 0 : jintArray jresult = jenv->NewIntArray(sz);
1115 0 : if (!jresult)
1116 0 : return NULL;
1117 0 : arr = jenv->GetIntArrayElements(jresult, 0);
1118 0 : if (!arr)
1119 0 : return NULL;
1120 0 : for (i=0; i<sz; i++)
1121 0 : arr[i] = (jint)result[i];
1122 0 : jenv->ReleaseIntArrayElements(jresult, arr, 0);
1123 0 : return jresult;
1124 : }
1125 :
1126 :
1127 : /* unsigned long[] support */
1128 0 : static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
1129 : int i;
1130 : jsize sz;
1131 0 : if (!input) {
1132 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1133 0 : return 0;
1134 : }
1135 0 : sz = jenv->GetArrayLength(input);
1136 0 : *jarr = jenv->GetLongArrayElements(input, 0);
1137 0 : if (!*jarr)
1138 0 : return 0;
1139 0 : *carr = new unsigned long[sz];
1140 0 : if (!*carr) {
1141 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1142 0 : return 0;
1143 : }
1144 0 : for (i=0; i<sz; i++)
1145 0 : (*carr)[i] = (unsigned long)(*jarr)[i];
1146 0 : return 1;
1147 : }
1148 :
1149 0 : static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
1150 : int i;
1151 0 : jsize sz = jenv->GetArrayLength(input);
1152 0 : for (i=0; i<sz; i++)
1153 0 : jarr[i] = (jlong)carr[i];
1154 0 : jenv->ReleaseLongArrayElements(input, jarr, 0);
1155 0 : }
1156 :
1157 0 : static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
1158 : jlong *arr;
1159 : int i;
1160 0 : jlongArray jresult = jenv->NewLongArray(sz);
1161 0 : if (!jresult)
1162 0 : return NULL;
1163 0 : arr = jenv->GetLongArrayElements(jresult, 0);
1164 0 : if (!arr)
1165 0 : return NULL;
1166 0 : for (i=0; i<sz; i++)
1167 0 : arr[i] = (jlong)result[i];
1168 0 : jenv->ReleaseLongArrayElements(jresult, arr, 0);
1169 0 : return jresult;
1170 : }
1171 :
1172 :
1173 : /* jlong[] support */
1174 0 : static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
1175 : int i;
1176 : jsize sz;
1177 0 : if (!input) {
1178 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1179 0 : return 0;
1180 : }
1181 0 : sz = jenv->GetArrayLength(input);
1182 0 : *jarr = jenv->GetLongArrayElements(input, 0);
1183 0 : if (!*jarr)
1184 0 : return 0;
1185 0 : *carr = new jlong[sz];
1186 0 : if (!*carr) {
1187 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1188 0 : return 0;
1189 : }
1190 0 : for (i=0; i<sz; i++)
1191 0 : (*carr)[i] = (jlong)(*jarr)[i];
1192 0 : return 1;
1193 : }
1194 :
1195 0 : static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
1196 : int i;
1197 0 : jsize sz = jenv->GetArrayLength(input);
1198 0 : for (i=0; i<sz; i++)
1199 0 : jarr[i] = (jlong)carr[i];
1200 0 : jenv->ReleaseLongArrayElements(input, jarr, 0);
1201 0 : }
1202 :
1203 0 : static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
1204 : jlong *arr;
1205 : int i;
1206 0 : jlongArray jresult = jenv->NewLongArray(sz);
1207 0 : if (!jresult)
1208 0 : return NULL;
1209 0 : arr = jenv->GetLongArrayElements(jresult, 0);
1210 0 : if (!arr)
1211 0 : return NULL;
1212 0 : for (i=0; i<sz; i++)
1213 0 : arr[i] = (jlong)result[i];
1214 0 : jenv->ReleaseLongArrayElements(jresult, arr, 0);
1215 0 : return jresult;
1216 : }
1217 :
1218 :
1219 : /* float[] support */
1220 0 : static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
1221 : int i;
1222 : jsize sz;
1223 0 : if (!input) {
1224 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1225 0 : return 0;
1226 : }
1227 0 : sz = jenv->GetArrayLength(input);
1228 0 : *jarr = jenv->GetFloatArrayElements(input, 0);
1229 0 : if (!*jarr)
1230 0 : return 0;
1231 0 : *carr = new float[sz];
1232 0 : if (!*carr) {
1233 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1234 0 : return 0;
1235 : }
1236 0 : for (i=0; i<sz; i++)
1237 0 : (*carr)[i] = (float)(*jarr)[i];
1238 0 : return 1;
1239 : }
1240 :
1241 0 : static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
1242 : int i;
1243 0 : jsize sz = jenv->GetArrayLength(input);
1244 0 : for (i=0; i<sz; i++)
1245 0 : jarr[i] = (jfloat)carr[i];
1246 0 : jenv->ReleaseFloatArrayElements(input, jarr, 0);
1247 0 : }
1248 :
1249 0 : static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
1250 : jfloat *arr;
1251 : int i;
1252 0 : jfloatArray jresult = jenv->NewFloatArray(sz);
1253 0 : if (!jresult)
1254 0 : return NULL;
1255 0 : arr = jenv->GetFloatArrayElements(jresult, 0);
1256 0 : if (!arr)
1257 0 : return NULL;
1258 0 : for (i=0; i<sz; i++)
1259 0 : arr[i] = (jfloat)result[i];
1260 0 : jenv->ReleaseFloatArrayElements(jresult, arr, 0);
1261 0 : return jresult;
1262 : }
1263 :
1264 :
1265 : /* double[] support */
1266 0 : static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
1267 : int i;
1268 : jsize sz;
1269 0 : if (!input) {
1270 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
1271 0 : return 0;
1272 : }
1273 0 : sz = jenv->GetArrayLength(input);
1274 0 : *jarr = jenv->GetDoubleArrayElements(input, 0);
1275 0 : if (!*jarr)
1276 0 : return 0;
1277 0 : *carr = new double[sz];
1278 0 : if (!*carr) {
1279 0 : SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
1280 0 : return 0;
1281 : }
1282 0 : for (i=0; i<sz; i++)
1283 0 : (*carr)[i] = (double)(*jarr)[i];
1284 0 : return 1;
1285 : }
1286 :
1287 0 : static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
1288 : int i;
1289 0 : jsize sz = jenv->GetArrayLength(input);
1290 0 : for (i=0; i<sz; i++)
1291 0 : jarr[i] = (jdouble)carr[i];
1292 0 : jenv->ReleaseDoubleArrayElements(input, jarr, 0);
1293 0 : }
1294 :
1295 0 : static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
1296 : jdouble *arr;
1297 : int i;
1298 0 : jdoubleArray jresult = jenv->NewDoubleArray(sz);
1299 0 : if (!jresult)
1300 0 : return NULL;
1301 0 : arr = jenv->GetDoubleArrayElements(jresult, 0);
1302 0 : if (!arr)
1303 0 : return NULL;
1304 0 : for (i=0; i<sz; i++)
1305 0 : arr[i] = (jdouble)result[i];
1306 0 : jenv->ReleaseDoubleArrayElements(jresult, arr, 0);
1307 0 : return jresult;
1308 : }
1309 :
1310 :
1311 : #endif
1312 :
1313 :
1314 : typedef char retStringAndCPLFree;
1315 :
1316 :
1317 0 : void Debug( const char *msg_class, const char *message ) {
1318 0 : CPLDebug( msg_class, "%s", message );
1319 0 : }
1320 :
1321 :
1322 0 : CPLErr SetErrorHandler( CPLErrorHandler pfnErrorHandler = NULL, void* user_data = NULL )
1323 : {
1324 0 : if( pfnErrorHandler == NULL )
1325 : {
1326 0 : pfnErrorHandler = CPLDefaultErrorHandler;
1327 : }
1328 :
1329 0 : CPLSetErrorHandlerEx( pfnErrorHandler, user_data );
1330 :
1331 0 : return CE_None;
1332 : }
1333 :
1334 :
1335 1 : CPLErr PushErrorHandler( char const * pszCallbackName = NULL ) {
1336 1 : CPLErrorHandler pfnHandler = NULL;
1337 1 : if( pszCallbackName == NULL || EQUAL(pszCallbackName,"CPLQuietErrorHandler") )
1338 1 : pfnHandler = CPLQuietErrorHandler;
1339 0 : else if( EQUAL(pszCallbackName,"CPLDefaultErrorHandler") )
1340 0 : pfnHandler = CPLDefaultErrorHandler;
1341 0 : else if( EQUAL(pszCallbackName,"CPLLoggingErrorHandler") )
1342 0 : pfnHandler = CPLLoggingErrorHandler;
1343 :
1344 1 : if ( pfnHandler == NULL )
1345 0 : return CE_Fatal;
1346 :
1347 1 : CPLPushErrorHandler( pfnHandler );
1348 :
1349 1 : return CE_None;
1350 : }
1351 :
1352 :
1353 0 : void Error( CPLErr msg_class, int err_code, const char* msg ) {
1354 0 : CPLError( msg_class, err_code, "%s", msg );
1355 0 : }
1356 :
1357 :
1358 0 : retStringAndCPLFree* EscapeString(int len, unsigned char *bin_string , int scheme) {
1359 0 : return CPLEscapeString((const char*)bin_string, len, scheme);
1360 : }
1361 :
1362 0 : retStringAndCPLFree* EscapeString(const char* str, int scheme) {
1363 0 : return CPLEscapeString(str, (str) ? strlen(str) : 0, scheme);
1364 : }
1365 :
1366 :
1367 0 : char **wrapper_VSIReadDirEx( const char * utf8_path, int nMaxFiles = 0 )
1368 : {
1369 0 : return VSIReadDirEx(utf8_path, nMaxFiles);
1370 : }
1371 :
1372 :
1373 0 : const char *wrapper_CPLGetConfigOption( const char * pszKey, const char * pszDefault = NULL )
1374 : {
1375 0 : return CPLGetConfigOption( pszKey, pszDefault );
1376 : }
1377 0 : const char *wrapper_CPLGetGlobalConfigOption( const char * pszKey, const char * pszDefault = NULL )
1378 : {
1379 0 : return CPLGetGlobalConfigOption( pszKey, pszDefault );
1380 : }
1381 0 : const char *wrapper_CPLGetThreadLocalConfigOption( const char * pszKey, const char * pszDefault = NULL )
1382 : {
1383 0 : return CPLGetThreadLocalConfigOption( pszKey, pszDefault );
1384 : }
1385 :
1386 :
1387 0 : char** wrapper_GetConfigOptions() {
1388 0 : char ** papszOpts = CPLGetConfigOptions();
1389 0 : char ** papszTLOpts = CPLGetThreadLocalConfigOptions();
1390 :
1391 0 : papszOpts = CSLMerge(papszOpts, papszTLOpts);
1392 :
1393 0 : CPLFree(papszTLOpts);
1394 :
1395 0 : return papszOpts;
1396 : };
1397 :
1398 :
1399 : /* Convert a char array to a Hashtable */
1400 : static jobject
1401 1 : GetCSLStringAsHashTable(JNIEnv *jenv, char **stringarray, bool bFreeCSL ) {
1402 1 : const jclass hashtable = jenv->FindClass("java/util/Hashtable");
1403 1 : const jmethodID constructor = jenv->GetMethodID(hashtable, "<init>", "()V");
1404 1 : const jmethodID put = jenv->GetMethodID(hashtable, "put",
1405 : "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
1406 1 : jobject jHashtable = jenv->NewObject(hashtable, constructor);
1407 1 : if ( stringarray != NULL ) {
1408 2 : while (*stringarray != NULL ) {
1409 : char const *valptr;
1410 : char *keyptr;
1411 1 : const char* pszSep = strchr( *stringarray, '=' );
1412 1 : if ( pszSep != NULL) {
1413 1 : keyptr = CPLStrdup(*stringarray);
1414 1 : keyptr[pszSep - *stringarray] = '\0';
1415 1 : valptr = pszSep + 1;
1416 1 : jstring name = jenv->NewStringUTF(keyptr);
1417 1 : jstring value = jenv->NewStringUTF(valptr);
1418 1 : jenv->CallObjectMethod(jHashtable, put, name, value);
1419 1 : jenv->DeleteLocalRef(name);
1420 1 : jenv->DeleteLocalRef(value);
1421 1 : CPLFree(keyptr);
1422 : }
1423 1 : stringarray++;
1424 : }
1425 : }
1426 1 : if( bFreeCSL )
1427 0 : CSLDestroy(stringarray);
1428 1 : return jHashtable;
1429 : }
1430 :
1431 :
1432 0 : void wrapper_VSISetCredential( const char* pszPathPrefix, const char * pszKey, const char * pszValue )
1433 : {
1434 0 : VSISetPathSpecificOption(pszPathPrefix, pszKey, pszValue);
1435 0 : }
1436 :
1437 0 : const char *wrapper_VSIGetCredential( const char* pszPathPrefix, const char * pszKey, const char * pszDefault = NULL )
1438 : {
1439 0 : return VSIGetPathSpecificOption( pszPathPrefix, pszKey, pszDefault );
1440 : }
1441 :
1442 0 : const char *wrapper_VSIGetPathSpecificOption( const char* pszPathPrefix, const char * pszKey, const char * pszDefault = NULL )
1443 : {
1444 0 : return VSIGetPathSpecificOption( pszPathPrefix, pszKey, pszDefault );
1445 : }
1446 :
1447 :
1448 0 : void wrapper_VSIClearCredentials(const char * pszPathPrefix = NULL)
1449 : {
1450 0 : VSIClearPathSpecificOptions( pszPathPrefix );
1451 0 : }
1452 0 : void wrapper_VSIClearPathSpecificOptions(const char * pszPathPrefix = NULL)
1453 : {
1454 0 : VSIClearPathSpecificOptions( pszPathPrefix );
1455 0 : }
1456 :
1457 :
1458 0 : VSI_RETVAL wrapper_VSIFileFromMemBuffer( const char* utf8_path, int nBytes, const GByte *pabyData)
1459 : {
1460 0 : GByte* pabyDataDup = (GByte*)VSIMalloc(nBytes);
1461 0 : if (pabyDataDup == NULL)
1462 0 : return -1;
1463 0 : memcpy(pabyDataDup, pabyData, nBytes);
1464 0 : VSILFILE *fp = VSIFileFromMemBuffer(utf8_path, (GByte*) pabyDataDup, nBytes, TRUE);
1465 :
1466 0 : if (fp == NULL) {
1467 0 : VSIFree(pabyDataDup);
1468 0 : return -1;
1469 : } else {
1470 0 : VSIFCloseL(fp);
1471 0 : return 0;
1472 : }
1473 : }
1474 :
1475 :
1476 :
1477 0 : bool wrapper_VSIUnlinkBatch(char** files)
1478 : {
1479 0 : int* success = VSIUnlinkBatch(files);
1480 0 : if( !success )
1481 0 : return false;
1482 0 : int bRet = true;
1483 0 : for( int i = 0; files && files[i]; i++ )
1484 : {
1485 0 : if( !success[i] ) {
1486 0 : bRet = false;
1487 0 : break;
1488 : }
1489 : }
1490 0 : VSIFree(success);
1491 0 : return bRet;
1492 : }
1493 :
1494 :
1495 17 : int wrapper_HasThreadSupport()
1496 : {
1497 17 : return strcmp(CPLGetThreadingModel(), "stub") != 0;
1498 : }
1499 :
1500 :
1501 0 : int wrapper_VSICopyFile(const char* pszSource,
1502 : const char* pszTarget,
1503 : VSILFILE* fpSource = NULL,
1504 : GIntBig nSourceSize = -1,
1505 : char** options = NULL,
1506 : GDALProgressFunc callback=NULL,
1507 : void* callback_data=NULL)
1508 : {
1509 0 : return VSICopyFile(
1510 : pszSource, pszTarget, fpSource,
1511 : nSourceSize < 0 ? static_cast<vsi_l_offset>(-1) : static_cast<vsi_l_offset>(nSourceSize),
1512 0 : options, callback, callback_data );
1513 : }
1514 :
1515 :
1516 0 : retStringAndCPLFree* wrapper_VSIGetSignedURL(const char * utf8_path, char** options = NULL )
1517 : {
1518 0 : return VSIGetSignedURL( utf8_path, options );
1519 : }
1520 :
1521 0 : SWIGINTERN CPLXMLNode *new_CPLXMLNode__SWIG_0(char const *pszString){
1522 0 : return CPLParseXMLString( pszString );
1523 : }
1524 0 : SWIGINTERN CPLXMLNode *new_CPLXMLNode__SWIG_1(CPLXMLNodeType eType,char const *pszText){
1525 0 : return CPLCreateXMLNode(NULL, eType, pszText);
1526 : }
1527 0 : SWIGINTERN void delete_CPLXMLNode(CPLXMLNode *self){
1528 0 : CPLDestroyXMLNode( self );
1529 0 : }
1530 0 : SWIGINTERN CPLXMLNode *CPLXMLNode_ParseXMLFile(char const *pszFilename){
1531 0 : return CPLParseXMLFile(pszFilename);
1532 : }
1533 0 : SWIGINTERN retStringAndCPLFree *CPLXMLNode_SerializeXMLTree(CPLXMLNode *self){
1534 0 : return CPLSerializeXMLTree( self );
1535 : }
1536 0 : SWIGINTERN retStringAndCPLFree *CPLXMLNode_toString(CPLXMLNode *self){
1537 0 : return CPLSerializeXMLTree( self );
1538 : }
1539 0 : SWIGINTERN CPLXMLNode *CPLXMLNode_SearchXMLNode(CPLXMLNode *self,char const *pszElement){
1540 0 : return CPLSearchXMLNode(self, pszElement);
1541 : }
1542 0 : SWIGINTERN CPLXMLNode *CPLXMLNode_GetXMLNode(CPLXMLNode *self,char const *pszPath){
1543 0 : return CPLGetXMLNode( self, pszPath );
1544 : }
1545 0 : SWIGINTERN char const *CPLXMLNode_GetXMLValue(CPLXMLNode *self,char const *pszPath,char const *pszDefault){
1546 0 : return CPLGetXMLValue( self, pszPath, pszDefault );
1547 : }
1548 0 : SWIGINTERN void CPLXMLNode_AddXMLChild(CPLXMLNode *self,CPLXMLNode *psChild){
1549 0 : CPLAddXMLChild( self, CPLCloneXMLTree(psChild) );
1550 0 : }
1551 0 : SWIGINTERN void CPLXMLNode_AddXMLSibling(CPLXMLNode *self,CPLXMLNode *psNewSibling){
1552 0 : CPLAddXMLSibling( self, CPLCloneXMLTree(psNewSibling) );
1553 0 : }
1554 0 : SWIGINTERN CPLXMLNode *CPLXMLNode_Clone(CPLXMLNode *self){
1555 0 : return CPLCloneXMLTree( self );
1556 : }
1557 0 : SWIGINTERN int CPLXMLNode_SetXMLValue(CPLXMLNode *self,char const *pszPath,char const *pszValue){
1558 0 : return CPLSetXMLValue( self, pszPath, pszValue );
1559 : }
1560 0 : SWIGINTERN void CPLXMLNode_StripXMLNamespace(CPLXMLNode *self,char const *pszNamespace,int bRecurse){
1561 0 : CPLStripXMLNamespace( self, pszNamespace, bRecurse );
1562 0 : }
1563 2 : SWIGINTERN char const *GDALMajorObjectShadow_GetDescription(GDALMajorObjectShadow *self){
1564 2 : return GDALGetDescription( self );
1565 : }
1566 1 : SWIGINTERN void GDALMajorObjectShadow_SetDescription(GDALMajorObjectShadow *self,char const *pszNewDesc){
1567 1 : GDALSetDescription( self, pszNewDesc );
1568 1 : }
1569 0 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadataDomainList(GDALMajorObjectShadow *self){
1570 0 : return GDALGetMetadataDomainList( self );
1571 : }
1572 1 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_Dict__SWIG_0(GDALMajorObjectShadow *self,char const *pszDomain=""){
1573 1 : return GDALGetMetadata( self, pszDomain );
1574 : }
1575 7 : SWIGINTERN char **GDALMajorObjectShadow_GetMetadata_List__SWIG_0(GDALMajorObjectShadow *self,char const *pszDomain=""){
1576 7 : return GDALGetMetadata( self, pszDomain );
1577 : }
1578 1 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_0(GDALMajorObjectShadow *self,char **papszMetadata,char const *pszDomain=""){
1579 1 : return GDALSetMetadata( self, papszMetadata, pszDomain );
1580 : }
1581 1 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadata__SWIG_2(GDALMajorObjectShadow *self,char *pszMetadataString,char const *pszDomain=""){
1582 : char *tmpList[2];
1583 1 : tmpList[0] = pszMetadataString;
1584 1 : tmpList[1] = 0;
1585 2 : return GDALSetMetadata( self, tmpList, pszDomain );
1586 : }
1587 3 : SWIGINTERN char const *GDALMajorObjectShadow_GetMetadataItem__SWIG_0(GDALMajorObjectShadow *self,char const *pszName,char const *pszDomain=""){
1588 3 : return GDALGetMetadataItem( self, pszName, pszDomain);
1589 : }
1590 1 : SWIGINTERN CPLErr GDALMajorObjectShadow_SetMetadataItem__SWIG_0(GDALMajorObjectShadow *self,char const *pszName,char const *pszValue,char const *pszDomain=""){
1591 1 : return GDALSetMetadataItem( self, pszName, pszValue, pszDomain);
1592 : }
1593 6 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_Create__SWIG_0(GDALDriverShadow *self,char const *utf8_path,int xsize,int ysize,int bands=1,GDALDataType eType=GDT_Byte,char **options=0){
1594 :
1595 6 : GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreate( self,
1596 : utf8_path,
1597 : xsize,
1598 : ysize,
1599 : bands,
1600 : eType,
1601 : options );
1602 6 : return ds;
1603 : }
1604 4 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateMultiDimensional__SWIG_0(GDALDriverShadow *self,char const *utf8_path,char **root_group_options=0,char **options=0){
1605 :
1606 4 : GDALDatasetShadow* ds = (GDALDatasetShadow*) GDALCreateMultiDimensional( self,
1607 : utf8_path,
1608 : root_group_options,
1609 : options );
1610 4 : return ds;
1611 : }
1612 0 : SWIGINTERN GDALDatasetShadow *GDALDriverShadow_CreateCopy__SWIG_0(GDALDriverShadow *self,char const *utf8_path,GDALDatasetShadow *src,int strict=1,char **options=0,GDALProgressFunc callback=NULL,void *callback_data=NULL){
1613 :
1614 0 : GDALDatasetShadow *ds = (GDALDatasetShadow*) GDALCreateCopy( self,
1615 : utf8_path,
1616 : src,
1617 : strict,
1618 : options,
1619 : callback,
1620 : callback_data );
1621 0 : return ds;
1622 : }
1623 0 : SWIGINTERN CPLErr GDALDriverShadow_Delete(GDALDriverShadow *self,char const *utf8_path){
1624 0 : return GDALDeleteDataset( self, utf8_path );
1625 : }
1626 0 : SWIGINTERN CPLErr GDALDriverShadow_Rename(GDALDriverShadow *self,char const *newName,char const *oldName){
1627 0 : return GDALRenameDataset( self, newName, oldName );
1628 : }
1629 0 : SWIGINTERN CPLErr GDALDriverShadow_CopyFiles(GDALDriverShadow *self,char const *newName,char const *oldName){
1630 0 : return GDALCopyDatasetFiles( self, newName, oldName );
1631 : }
1632 0 : SWIGINTERN int GDALDriverShadow_Register(GDALDriverShadow *self){
1633 0 : return GDALRegisterDriver( self );
1634 : }
1635 0 : SWIGINTERN void GDALDriverShadow_Deregister(GDALDriverShadow *self){
1636 0 : GDALDeregisterDriver( self );
1637 0 : }
1638 :
1639 1 : char const *GDALDriverShadow_ShortName_get( GDALDriverShadow *h ) {
1640 1 : return GDALGetDriverShortName( h );
1641 : }
1642 1 : char const *GDALDriverShadow_LongName_get( GDALDriverShadow *h ) {
1643 1 : return GDALGetDriverLongName( h );
1644 : }
1645 0 : char const *GDALDriverShadow_HelpTopic_get( GDALDriverShadow *h ) {
1646 0 : return GDALGetDriverHelpTopic( h );
1647 : }
1648 :
1649 0 : SWIGINTERN GDAL_GCP *new_GDAL_GCP(double x,double y,double z,double pixel,double line,char const *info,char const *id){
1650 :
1651 :
1652 :
1653 :
1654 :
1655 0 : GDAL_GCP *self = (GDAL_GCP*) CPLMalloc( sizeof( GDAL_GCP ) );
1656 0 : self->dfGCPX = x;
1657 0 : self->dfGCPY = y;
1658 0 : self->dfGCPZ = z;
1659 0 : self->dfGCPPixel = pixel;
1660 0 : self->dfGCPLine = line;
1661 0 : self->pszInfo = CPLStrdup( (info == 0) ? "" : info );
1662 0 : self->pszId = CPLStrdup( (id==0)? "" : id );
1663 0 : return self;
1664 : }
1665 0 : SWIGINTERN void delete_GDAL_GCP(GDAL_GCP *self){
1666 0 : if ( self->pszInfo )
1667 0 : CPLFree( self->pszInfo );
1668 0 : if ( self->pszId )
1669 0 : CPLFree( self->pszId );
1670 0 : CPLFree( self );
1671 0 : }
1672 :
1673 :
1674 0 : double GDAL_GCP_GCPX_get( GDAL_GCP *gcp ) {
1675 0 : return gcp->dfGCPX;
1676 : }
1677 0 : void GDAL_GCP_GCPX_set( GDAL_GCP *gcp, double dfGCPX ) {
1678 0 : gcp->dfGCPX = dfGCPX;
1679 0 : }
1680 0 : double GDAL_GCP_GCPY_get( GDAL_GCP *gcp ) {
1681 0 : return gcp->dfGCPY;
1682 : }
1683 0 : void GDAL_GCP_GCPY_set( GDAL_GCP *gcp, double dfGCPY ) {
1684 0 : gcp->dfGCPY = dfGCPY;
1685 0 : }
1686 0 : double GDAL_GCP_GCPZ_get( GDAL_GCP *gcp ) {
1687 0 : return gcp->dfGCPZ;
1688 : }
1689 0 : void GDAL_GCP_GCPZ_set( GDAL_GCP *gcp, double dfGCPZ ) {
1690 0 : gcp->dfGCPZ = dfGCPZ;
1691 0 : }
1692 0 : double GDAL_GCP_GCPPixel_get( GDAL_GCP *gcp ) {
1693 0 : return gcp->dfGCPPixel;
1694 : }
1695 0 : void GDAL_GCP_GCPPixel_set( GDAL_GCP *gcp, double dfGCPPixel ) {
1696 0 : gcp->dfGCPPixel = dfGCPPixel;
1697 0 : }
1698 0 : double GDAL_GCP_GCPLine_get( GDAL_GCP *gcp ) {
1699 0 : return gcp->dfGCPLine;
1700 : }
1701 0 : void GDAL_GCP_GCPLine_set( GDAL_GCP *gcp, double dfGCPLine ) {
1702 0 : gcp->dfGCPLine = dfGCPLine;
1703 0 : }
1704 0 : const char * GDAL_GCP_Info_get( GDAL_GCP *gcp ) {
1705 0 : return gcp->pszInfo;
1706 : }
1707 0 : void GDAL_GCP_Info_set( GDAL_GCP *gcp, const char * pszInfo ) {
1708 0 : if ( gcp->pszInfo )
1709 0 : CPLFree( gcp->pszInfo );
1710 0 : gcp->pszInfo = CPLStrdup(pszInfo);
1711 0 : }
1712 0 : const char * GDAL_GCP_Id_get( GDAL_GCP *gcp ) {
1713 0 : return gcp->pszId;
1714 : }
1715 0 : void GDAL_GCP_Id_set( GDAL_GCP *gcp, const char * pszId ) {
1716 0 : if ( gcp->pszId )
1717 0 : CPLFree( gcp->pszId );
1718 0 : gcp->pszId = CPLStrdup(pszId);
1719 0 : }
1720 :
1721 :
1722 0 : int wrapper_GDALGCPsToGeoTransform( int nGCPs, GDAL_GCP const * pGCPs,
1723 : double argout[6], int bApproxOK = 1 )
1724 : {
1725 0 : return GDALGCPsToGeoTransform(nGCPs, pGCPs, argout, bApproxOK);
1726 : }
1727 :
1728 :
1729 : /* Returned size is in bytes or 0 if an error occurred. */
1730 : static
1731 2 : GIntBig ComputeDatasetRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
1732 : int nBands, int* bandMap, int nBandMapArrayLength,
1733 : GIntBig nPixelSpace, GIntBig nLineSpace, GIntBig nBandSpace,
1734 : int bSpacingShouldBeMultipleOfPixelSize )
1735 : {
1736 2 : if (buf_xsize <= 0 || buf_ysize <= 0)
1737 : {
1738 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
1739 0 : return 0;
1740 : }
1741 :
1742 2 : if (nPixelSpace < 0 || nLineSpace < 0 || nBandSpace < 0)
1743 : {
1744 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for space arguments");
1745 0 : return 0;
1746 : }
1747 :
1748 2 : if (nPixelSize == 0)
1749 : {
1750 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal value for data type");
1751 0 : return 0;
1752 : }
1753 :
1754 2 : if( nPixelSpace == 0 )
1755 2 : nPixelSpace = nPixelSize;
1756 0 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nPixelSpace % nPixelSize) != 0 )
1757 : {
1758 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nPixelSpace should be a multiple of nPixelSize");
1759 0 : return 0;
1760 : }
1761 :
1762 2 : if( nLineSpace == 0 )
1763 : {
1764 2 : nLineSpace = nPixelSpace * buf_xsize;
1765 : }
1766 0 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nLineSpace % nPixelSize) != 0 )
1767 : {
1768 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
1769 0 : return 0;
1770 : }
1771 :
1772 2 : if( nBandSpace == 0 )
1773 : {
1774 2 : nBandSpace = nLineSpace * buf_ysize;
1775 : }
1776 0 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nBandSpace % nPixelSize) != 0 )
1777 : {
1778 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
1779 0 : return 0;
1780 : }
1781 :
1782 2 : if (nBands <= 0 || (bandMap != NULL && nBands > nBandMapArrayLength))
1783 : {
1784 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Invalid band count");
1785 0 : return 0;
1786 : }
1787 :
1788 2 : GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + (GIntBig)(nBands - 1) * nBandSpace + nPixelSize;
1789 : #if SIZEOF_VOIDP == 4
1790 : if (nRet > INT_MAX)
1791 : {
1792 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
1793 : return 0;
1794 : }
1795 : #endif
1796 :
1797 2 : return nRet;
1798 : }
1799 :
1800 9 : SWIGINTERN void delete_GDALDatasetShadow(GDALDatasetShadow *self){
1801 9 : if ( GDALDereferenceDataset( self ) <= 0 ) {
1802 9 : if( GDALClose(self) != CE_None )
1803 : {
1804 0 : if( CPLGetLastErrorType() == CE_None )
1805 0 : CPLError(CE_Failure, CPLE_AppDefined, "Error occurred in GDALClose()");
1806 : }
1807 : }
1808 9 : }
1809 0 : SWIGINTERN CPLErr GDALDatasetShadow_Close(GDALDatasetShadow *self){
1810 0 : return GDALClose(self);
1811 : }
1812 1 : SWIGINTERN GDALDriverShadow *GDALDatasetShadow_GetDriver(GDALDatasetShadow *self){
1813 1 : return (GDALDriverShadow*) GDALGetDatasetDriver( self );
1814 : }
1815 9 : SWIGINTERN GDALRasterBandShadow *GDALDatasetShadow_GetRasterBand(GDALDatasetShadow *self,int nBand){
1816 9 : return (GDALRasterBandShadow*) GDALGetRasterBand( self, nBand );
1817 : }
1818 4 : SWIGINTERN GDALGroupHS *GDALDatasetShadow_GetRootGroup(GDALDatasetShadow *self){
1819 4 : return GDALDatasetGetRootGroup(self);
1820 : }
1821 1 : SWIGINTERN char const *GDALDatasetShadow_GetProjection(GDALDatasetShadow *self){
1822 1 : return GDALGetProjectionRef( self );
1823 : }
1824 8 : SWIGINTERN char const *GDALDatasetShadow_GetProjectionRef(GDALDatasetShadow *self){
1825 8 : return GDALGetProjectionRef( self );
1826 : }
1827 0 : SWIGINTERN OSRSpatialReferenceShadow *GDALDatasetShadow_GetSpatialRef(GDALDatasetShadow *self){
1828 0 : OGRSpatialReferenceH ref = GDALGetSpatialRef(self);
1829 0 : if( ref )
1830 0 : ref = OSRClone( ref );
1831 0 : return (OSRSpatialReferenceShadow*) ref;
1832 : }
1833 0 : SWIGINTERN CPLErr GDALDatasetShadow_SetProjection(GDALDatasetShadow *self,char const *prj){
1834 0 : return GDALSetProjection( self, prj );
1835 : }
1836 0 : SWIGINTERN CPLErr GDALDatasetShadow_SetSpatialRef(GDALDatasetShadow *self,OSRSpatialReferenceShadow *srs){
1837 0 : return GDALSetSpatialRef( self, (OGRSpatialReferenceH)srs );
1838 : }
1839 6 : SWIGINTERN void GDALDatasetShadow_GetGeoTransform(GDALDatasetShadow *self,double argout[6]){
1840 6 : if ( GDALGetGeoTransform( self, argout ) != CE_None ) {
1841 0 : argout[0] = 0.0;
1842 0 : argout[1] = 1.0;
1843 0 : argout[2] = 0.0;
1844 0 : argout[3] = 0.0;
1845 0 : argout[4] = 0.0;
1846 0 : argout[5] = 1.0;
1847 : }
1848 6 : }
1849 0 : SWIGINTERN CPLErr GDALDatasetShadow_SetGeoTransform(GDALDatasetShadow *self,double argin[6]){
1850 0 : return GDALSetGeoTransform( self, argin );
1851 : }
1852 1 : SWIGINTERN int GDALDatasetShadow_BuildOverviews__SWIG_0(GDALDatasetShadow *self,char const *resampling,int overviewlist,int *pOverviews,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=NULL){
1853 :
1854 :
1855 :
1856 :
1857 :
1858 :
1859 :
1860 1 : return GDALBuildOverviewsEx( self,
1861 : resampling ? resampling : "NEAREST",
1862 : overviewlist,
1863 : pOverviews,
1864 : 0,
1865 : 0,
1866 : callback,
1867 : callback_data,
1868 1 : options);
1869 : }
1870 1 : SWIGINTERN int GDALDatasetShadow_GetGCPCount(GDALDatasetShadow *self){
1871 1 : return GDALGetGCPCount( self );
1872 : }
1873 0 : SWIGINTERN char const *GDALDatasetShadow_GetGCPProjection(GDALDatasetShadow *self){
1874 0 : return GDALGetGCPProjection( self );
1875 : }
1876 0 : SWIGINTERN OSRSpatialReferenceShadow *GDALDatasetShadow_GetGCPSpatialRef(GDALDatasetShadow *self){
1877 0 : OGRSpatialReferenceH ref = GDALGetGCPSpatialRef(self);
1878 0 : if( ref )
1879 0 : ref = OSRClone( ref );
1880 0 : return (OSRSpatialReferenceShadow*) ref;
1881 : }
1882 0 : SWIGINTERN void GDALDatasetShadow_GetGCPs(GDALDatasetShadow *self,int *nGCPs,GDAL_GCP const **pGCPs){
1883 0 : *nGCPs = GDALGetGCPCount( self );
1884 0 : *pGCPs = GDALGetGCPs( self );
1885 0 : }
1886 0 : SWIGINTERN CPLErr GDALDatasetShadow_SetGCPs(GDALDatasetShadow *self,int nGCPs,GDAL_GCP const *pGCPs,char const *pszGCPProjection){
1887 0 : return GDALSetGCPs( self, nGCPs, pGCPs, pszGCPProjection );
1888 : }
1889 0 : SWIGINTERN CPLErr GDALDatasetShadow_SetGCPs2(GDALDatasetShadow *self,int nGCPs,GDAL_GCP const *pGCPs,OSRSpatialReferenceShadow *hSRS){
1890 0 : return GDALSetGCPs2( self, nGCPs, pGCPs, (OGRSpatialReferenceH)hSRS );
1891 : }
1892 0 : SWIGINTERN CPLErr GDALDatasetShadow_FlushCache(GDALDatasetShadow *self){
1893 0 : return GDALFlushCache( self );
1894 : }
1895 0 : SWIGINTERN CPLErr GDALDatasetShadow_AddBand__SWIG_0(GDALDatasetShadow *self,GDALDataType datatype=GDT_Byte,char **options=0){
1896 0 : return GDALAddBand( self, datatype, options );
1897 : }
1898 0 : SWIGINTERN CPLErr GDALDatasetShadow_CreateMaskBand(GDALDatasetShadow *self,int nFlags){
1899 0 : return GDALCreateDatasetMaskBand( self, nFlags );
1900 : }
1901 1 : SWIGINTERN char **GDALDatasetShadow_GetFileList(GDALDatasetShadow *self){
1902 1 : return GDALGetFileList( self );
1903 : }
1904 0 : SWIGINTERN CPLErr GDALDatasetShadow_AdviseRead__SWIG_0(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){
1905 0 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
1906 0 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
1907 : GDALDataType ntype;
1908 0 : if ( buf_type != 0 ) {
1909 0 : ntype = (GDALDataType) *buf_type;
1910 : } else {
1911 0 : int lastband = GDALGetRasterCount( self );
1912 0 : if (lastband <= 0)
1913 0 : return CE_Failure;
1914 0 : ntype = GDALGetRasterDataType( GDALGetRasterBand( self, lastband ) );
1915 : }
1916 0 : return GDALDatasetAdviseRead(self, xoff, yoff, xsize, ysize,
1917 : nxsize, nysize, ntype,
1918 0 : band_list, pband_list, options);
1919 : }
1920 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CreateLayer__SWIG_0(GDALDatasetShadow *self,char const *name,OSRSpatialReferenceShadow *srs=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
1921 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCreateLayer( self,
1922 : name,
1923 : srs,
1924 : geom_type,
1925 : options);
1926 0 : return layer;
1927 : }
1928 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CreateLayerFromGeomFieldDefn__SWIG_0(GDALDatasetShadow *self,char const *name,OGRGeomFieldDefnShadow *geom_field,char **options=0){
1929 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCreateLayerFromGeomFieldDefn( self,
1930 : name,
1931 : geom_field,
1932 : options);
1933 0 : return layer;
1934 : }
1935 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_CopyLayer__SWIG_0(GDALDatasetShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
1936 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCopyLayer( self,
1937 : src_layer,
1938 : new_name,
1939 : options);
1940 0 : return layer;
1941 : }
1942 0 : SWIGINTERN OGRErr GDALDatasetShadow_DeleteLayer(GDALDatasetShadow *self,int index){
1943 0 : return GDALDatasetDeleteLayer(self, index);
1944 : }
1945 :
1946 :
1947 : #include "ogr_core.h"
1948 : static char const *
1949 0 : OGRErrMessages( int rc ) {
1950 0 : switch( rc ) {
1951 0 : case OGRERR_NONE:
1952 0 : return "OGR Error: None";
1953 0 : case OGRERR_NOT_ENOUGH_DATA:
1954 0 : return "OGR Error: Not enough data to deserialize";
1955 0 : case OGRERR_NOT_ENOUGH_MEMORY:
1956 0 : return "OGR Error: Not enough memory";
1957 0 : case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
1958 0 : return "OGR Error: Unsupported geometry type";
1959 0 : case OGRERR_UNSUPPORTED_OPERATION:
1960 0 : return "OGR Error: Unsupported operation";
1961 0 : case OGRERR_CORRUPT_DATA:
1962 0 : return "OGR Error: Corrupt data";
1963 0 : case OGRERR_FAILURE:
1964 0 : return "OGR Error: General Error";
1965 0 : case OGRERR_UNSUPPORTED_SRS:
1966 0 : return "OGR Error: Unsupported SRS";
1967 0 : case OGRERR_INVALID_HANDLE:
1968 0 : return "OGR Error: Invalid handle";
1969 0 : case OGRERR_NON_EXISTING_FEATURE:
1970 0 : return "OGR Error: Non existing feature";
1971 0 : default:
1972 0 : return "OGR Error: Unknown";
1973 : }
1974 : }
1975 :
1976 0 : SWIGINTERN bool GDALDatasetShadow_IsLayerPrivate(GDALDatasetShadow *self,int index){
1977 0 : return GDALDatasetIsLayerPrivate(self, index);
1978 : }
1979 0 : SWIGINTERN OGRFeatureShadow *GDALDatasetShadow_GetNextFeature(GDALDatasetShadow *self){
1980 0 : return GDALDatasetGetNextFeature( self, NULL, NULL, NULL, NULL );
1981 : }
1982 0 : SWIGINTERN bool GDALDatasetShadow_TestCapability(GDALDatasetShadow *self,char const *cap){
1983 0 : return (GDALDatasetTestCapability(self, cap) > 0);
1984 : }
1985 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_ExecuteSQL__SWIG_0(GDALDatasetShadow *self,char const *statement,OGRGeometryShadow *spatialFilter=NULL,char const *dialect=""){
1986 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetExecuteSQL(self,
1987 : statement,
1988 : spatialFilter,
1989 : dialect);
1990 0 : return layer;
1991 : }
1992 0 : SWIGINTERN void GDALDatasetShadow_ReleaseResultSet(GDALDatasetShadow *self,OGRLayerShadow *layer){
1993 0 : GDALDatasetReleaseResultSet(self, layer);
1994 0 : }
1995 0 : SWIGINTERN OGRStyleTableShadow *GDALDatasetShadow_GetStyleTable(GDALDatasetShadow *self){
1996 0 : return (OGRStyleTableShadow*) GDALDatasetGetStyleTable(self);
1997 : }
1998 0 : SWIGINTERN void GDALDatasetShadow_SetStyleTable(GDALDatasetShadow *self,OGRStyleTableShadow *table){
1999 0 : if( table != NULL )
2000 0 : GDALDatasetSetStyleTable(self, (OGRStyleTableH) table);
2001 0 : }
2002 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_GetLayerByIndex(GDALDatasetShadow *self,int index){
2003 :
2004 :
2005 :
2006 :
2007 :
2008 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetGetLayer(self, index);
2009 0 : return layer;
2010 : }
2011 0 : SWIGINTERN OGRLayerShadow *GDALDatasetShadow_GetLayerByName(GDALDatasetShadow *self,char const *layer_name){
2012 0 : OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetGetLayerByName(self, layer_name);
2013 0 : return layer;
2014 : }
2015 0 : SWIGINTERN void GDALDatasetShadow_ResetReading(GDALDatasetShadow *self){
2016 0 : GDALDatasetResetReading(self);
2017 0 : }
2018 0 : SWIGINTERN int GDALDatasetShadow_GetLayerCount(GDALDatasetShadow *self){
2019 0 : return GDALDatasetGetLayerCount(self);
2020 : }
2021 0 : SWIGINTERN OGRErr GDALDatasetShadow_AbortSQL(GDALDatasetShadow *self){
2022 0 : return GDALDatasetAbortSQL(self);
2023 : }
2024 0 : SWIGINTERN OGRErr GDALDatasetShadow_StartTransaction__SWIG_0(GDALDatasetShadow *self,int force=FALSE){
2025 0 : return GDALDatasetStartTransaction(self, force);
2026 : }
2027 0 : SWIGINTERN OGRErr GDALDatasetShadow_CommitTransaction(GDALDatasetShadow *self){
2028 0 : return GDALDatasetCommitTransaction(self);
2029 : }
2030 0 : SWIGINTERN OGRErr GDALDatasetShadow_RollbackTransaction(GDALDatasetShadow *self){
2031 0 : return GDALDatasetRollbackTransaction(self);
2032 : }
2033 0 : SWIGINTERN void GDALDatasetShadow_ClearStatistics(GDALDatasetShadow *self){
2034 0 : GDALDatasetClearStatistics(self);
2035 0 : }
2036 0 : SWIGINTERN char **GDALDatasetShadow_GetFieldDomainNames__SWIG_0(GDALDatasetShadow *self,char **options=0){
2037 0 : return GDALDatasetGetFieldDomainNames(self, options);
2038 : }
2039 0 : SWIGINTERN OGRFieldDomainShadow *GDALDatasetShadow_GetFieldDomain(GDALDatasetShadow *self,char const *name){
2040 0 : return (OGRFieldDomainShadow*) GDALDatasetGetFieldDomain(self, name);
2041 : }
2042 0 : SWIGINTERN bool GDALDatasetShadow_AddFieldDomain(GDALDatasetShadow *self,OGRFieldDomainShadow *fieldDomain){
2043 0 : return GDALDatasetAddFieldDomain(self, (OGRFieldDomainH)fieldDomain, NULL);
2044 : }
2045 0 : SWIGINTERN bool GDALDatasetShadow_DeleteFieldDomain(GDALDatasetShadow *self,char const *name){
2046 0 : return GDALDatasetDeleteFieldDomain(self, name, NULL);
2047 : }
2048 0 : SWIGINTERN bool GDALDatasetShadow_UpdateFieldDomain(GDALDatasetShadow *self,OGRFieldDomainShadow *fieldDomain){
2049 0 : return GDALDatasetUpdateFieldDomain(self, (OGRFieldDomainH)fieldDomain, NULL);
2050 : }
2051 0 : SWIGINTERN char **GDALDatasetShadow_GetRelationshipNames__SWIG_0(GDALDatasetShadow *self,char **options=0){
2052 0 : return GDALDatasetGetRelationshipNames(self, options);
2053 : }
2054 0 : SWIGINTERN GDALRelationshipShadow *GDALDatasetShadow_GetRelationship(GDALDatasetShadow *self,char const *name){
2055 0 : return (GDALRelationshipShadow*) GDALDatasetGetRelationship(self, name);
2056 : }
2057 0 : SWIGINTERN bool GDALDatasetShadow_AddRelationship(GDALDatasetShadow *self,GDALRelationshipShadow *relationship){
2058 0 : return GDALDatasetAddRelationship(self, (GDALRelationshipH)relationship, NULL);
2059 : }
2060 0 : SWIGINTERN bool GDALDatasetShadow_DeleteRelationship(GDALDatasetShadow *self,char const *name){
2061 0 : return GDALDatasetDeleteRelationship(self, name, NULL);
2062 : }
2063 0 : SWIGINTERN bool GDALDatasetShadow_UpdateRelationship(GDALDatasetShadow *self,GDALRelationshipShadow *relationship){
2064 0 : return GDALDatasetUpdateRelationship(self, (GDALRelationshipH)relationship, NULL);
2065 : }
2066 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster_Direct__SWIG_0(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,void *nioBuffer,size_t nioBufferSize,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2067 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2068 : xoff, yoff, xsize, ysize,
2069 : buf_xsize, buf_ysize,
2070 : buf_type,
2071 : nioBuffer, nioBufferSize,
2072 : band_list, pband_list,
2073 : nPixelSpace, nLineSpace, nBandSpace,
2074 0 : GDT_Unknown, 0);
2075 : }
2076 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_0(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,char *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2077 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2078 : xoff, yoff, xsize, ysize,
2079 : buf_xsize, buf_ysize,
2080 : buf_type,
2081 : regularArrayOut, nRegularArraySizeOut,
2082 : band_list, pband_list,
2083 : nPixelSpace, nLineSpace, nBandSpace,
2084 0 : GDT_Byte, sizeof(char));
2085 : }
2086 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_4(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,short *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2087 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2088 : xoff, yoff, xsize, ysize,
2089 : buf_xsize, buf_ysize,
2090 : buf_type,
2091 : regularArrayOut, nRegularArraySizeOut,
2092 : band_list, pband_list,
2093 : nPixelSpace, nLineSpace, nBandSpace,
2094 0 : GDT_Int16, sizeof(short));
2095 : }
2096 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_8(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2097 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2098 : xoff, yoff, xsize, ysize,
2099 : buf_xsize, buf_ysize,
2100 : buf_type,
2101 : regularArrayOut, nRegularArraySizeOut,
2102 : band_list, pband_list,
2103 : nPixelSpace, nLineSpace, nBandSpace,
2104 0 : GDT_Int32, sizeof(int));
2105 : }
2106 1 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_12(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int64_t *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2107 1 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2108 : xoff, yoff, xsize, ysize,
2109 : buf_xsize, buf_ysize,
2110 : buf_type,
2111 : regularArrayOut, nRegularArraySizeOut,
2112 : band_list, pband_list,
2113 : nPixelSpace, nLineSpace, nBandSpace,
2114 1 : GDT_Int64, sizeof(int64_t));
2115 : }
2116 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_16(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,float *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2117 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2118 : xoff, yoff, xsize, ysize,
2119 : buf_xsize, buf_ysize,
2120 : buf_type,
2121 : regularArrayOut, nRegularArraySizeOut,
2122 : band_list, pband_list,
2123 : nPixelSpace, nLineSpace, nBandSpace,
2124 0 : GDT_Float32, sizeof(float));
2125 : }
2126 0 : SWIGINTERN CPLErr GDALDatasetShadow_ReadRaster__SWIG_20(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,double *regularArrayOut,size_t nRegularArraySizeOut,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2127 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Read,
2128 : xoff, yoff, xsize, ysize,
2129 : buf_xsize, buf_ysize,
2130 : buf_type,
2131 : regularArrayOut, nRegularArraySizeOut,
2132 : band_list, pband_list,
2133 : nPixelSpace, nLineSpace, nBandSpace,
2134 0 : GDT_Float64, sizeof(double));
2135 : }
2136 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster_Direct__SWIG_0(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,void *nioBuffer,size_t nioBufferSize,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2137 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2138 : xoff, yoff, xsize, ysize,
2139 : buf_xsize, buf_ysize,
2140 : buf_type,
2141 : nioBuffer, nioBufferSize,
2142 : band_list, pband_list,
2143 : nPixelSpace, nLineSpace, nBandSpace,
2144 0 : GDT_Unknown, 0);
2145 : }
2146 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_0(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,char *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2147 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2148 : xoff, yoff, xsize, ysize,
2149 : buf_xsize, buf_ysize,
2150 : buf_type,
2151 : regularArrayIn, nRegularArraySizeIn,
2152 : band_list, pband_list,
2153 : nPixelSpace, nLineSpace, nBandSpace,
2154 0 : GDT_Byte, sizeof(char));
2155 : }
2156 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_4(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,short *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2157 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2158 : xoff, yoff, xsize, ysize,
2159 : buf_xsize, buf_ysize,
2160 : buf_type,
2161 : regularArrayIn, nRegularArraySizeIn,
2162 : band_list, pband_list,
2163 : nPixelSpace, nLineSpace, nBandSpace,
2164 0 : GDT_Int16, sizeof(short));
2165 : }
2166 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_8(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2167 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2168 : xoff, yoff, xsize, ysize,
2169 : buf_xsize, buf_ysize,
2170 : buf_type,
2171 : regularArrayIn, nRegularArraySizeIn,
2172 : band_list, pband_list,
2173 : nPixelSpace, nLineSpace, nBandSpace,
2174 0 : GDT_Int32, sizeof(int));
2175 : }
2176 1 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_12(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int64_t *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2177 1 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2178 : xoff, yoff, xsize, ysize,
2179 : buf_xsize, buf_ysize,
2180 : buf_type,
2181 : regularArrayIn, nRegularArraySizeIn,
2182 : band_list, pband_list,
2183 : nPixelSpace, nLineSpace, nBandSpace,
2184 1 : GDT_Int64, sizeof(int64_t));
2185 : }
2186 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_16(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,float *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2187 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2188 : xoff, yoff, xsize, ysize,
2189 : buf_xsize, buf_ysize,
2190 : buf_type,
2191 : regularArrayIn, nRegularArraySizeIn,
2192 : band_list, pband_list,
2193 : nPixelSpace, nLineSpace, nBandSpace,
2194 0 : GDT_Float32, sizeof(float));
2195 : }
2196 0 : SWIGINTERN CPLErr GDALDatasetShadow_WriteRaster__SWIG_20(GDALDatasetShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,double *regularArrayIn,size_t nRegularArraySizeIn,int band_list,int *pband_list,int nPixelSpace=0,int nLineSpace=0,int nBandSpace=0){
2197 0 : return DatasetRasterIO( (GDALDatasetH)self, GF_Write,
2198 : xoff, yoff, xsize, ysize,
2199 : buf_xsize, buf_ysize,
2200 : buf_type,
2201 : regularArrayIn, nRegularArraySizeIn,
2202 : band_list, pband_list,
2203 : nPixelSpace, nLineSpace, nBandSpace,
2204 0 : GDT_Float64, sizeof(double));
2205 : }
2206 :
2207 5 : int GDALDatasetShadow_RasterXSize_get( GDALDatasetShadow *h ) {
2208 5 : return GDALGetRasterXSize( h );
2209 : }
2210 5 : int GDALDatasetShadow_RasterYSize_get( GDALDatasetShadow *h ) {
2211 5 : return GDALGetRasterYSize( h );
2212 : }
2213 5 : int GDALDatasetShadow_RasterCount_get( GDALDatasetShadow *h ) {
2214 5 : return GDALGetRasterCount( h );
2215 : }
2216 :
2217 0 : SWIGINTERN GDALRasterAttributeTableShadow *new_GDALRasterAttributeTableShadow(){
2218 : return (GDALRasterAttributeTableShadow*)
2219 0 : GDALCreateRasterAttributeTable();
2220 : }
2221 0 : SWIGINTERN void delete_GDALRasterAttributeTableShadow(GDALRasterAttributeTableShadow *self){
2222 0 : GDALDestroyRasterAttributeTable(self);
2223 0 : }
2224 0 : SWIGINTERN GDALRasterAttributeTableShadow *GDALRasterAttributeTableShadow_Clone(GDALRasterAttributeTableShadow *self){
2225 0 : return (GDALRasterAttributeTableShadow*) GDALRATClone(self);
2226 : }
2227 0 : SWIGINTERN int GDALRasterAttributeTableShadow_GetColumnCount(GDALRasterAttributeTableShadow *self){
2228 0 : return GDALRATGetColumnCount( self );
2229 : }
2230 0 : SWIGINTERN char const *GDALRasterAttributeTableShadow_GetNameOfCol(GDALRasterAttributeTableShadow *self,int iCol){
2231 0 : return GDALRATGetNameOfCol( self, iCol );
2232 : }
2233 0 : SWIGINTERN GDALRATFieldUsage GDALRasterAttributeTableShadow_GetUsageOfCol(GDALRasterAttributeTableShadow *self,int iCol){
2234 0 : return GDALRATGetUsageOfCol( self, iCol );
2235 : }
2236 0 : SWIGINTERN GDALRATFieldType GDALRasterAttributeTableShadow_GetTypeOfCol(GDALRasterAttributeTableShadow *self,int iCol){
2237 0 : return GDALRATGetTypeOfCol( self, iCol );
2238 : }
2239 0 : SWIGINTERN int GDALRasterAttributeTableShadow_GetColOfUsage(GDALRasterAttributeTableShadow *self,GDALRATFieldUsage eUsage){
2240 0 : return GDALRATGetColOfUsage( self, eUsage );
2241 : }
2242 0 : SWIGINTERN int GDALRasterAttributeTableShadow_GetRowCount(GDALRasterAttributeTableShadow *self){
2243 0 : return GDALRATGetRowCount( self );
2244 : }
2245 0 : SWIGINTERN char const *GDALRasterAttributeTableShadow_GetValueAsString(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
2246 0 : return GDALRATGetValueAsString( self, iRow, iCol );
2247 : }
2248 0 : SWIGINTERN int GDALRasterAttributeTableShadow_GetValueAsInt(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
2249 0 : return GDALRATGetValueAsInt( self, iRow, iCol );
2250 : }
2251 0 : SWIGINTERN double GDALRasterAttributeTableShadow_GetValueAsDouble(GDALRasterAttributeTableShadow *self,int iRow,int iCol){
2252 0 : return GDALRATGetValueAsDouble( self, iRow, iCol );
2253 : }
2254 0 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsString(GDALRasterAttributeTableShadow *self,int iRow,int iCol,char const *pszValue){
2255 0 : GDALRATSetValueAsString( self, iRow, iCol, pszValue );
2256 0 : }
2257 0 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsInt(GDALRasterAttributeTableShadow *self,int iRow,int iCol,int nValue){
2258 0 : GDALRATSetValueAsInt( self, iRow, iCol, nValue );
2259 0 : }
2260 0 : SWIGINTERN void GDALRasterAttributeTableShadow_SetValueAsDouble(GDALRasterAttributeTableShadow *self,int iRow,int iCol,double dfValue){
2261 0 : GDALRATSetValueAsDouble( self, iRow, iCol, dfValue );
2262 0 : }
2263 0 : SWIGINTERN void GDALRasterAttributeTableShadow_SetRowCount(GDALRasterAttributeTableShadow *self,int nCount){
2264 0 : GDALRATSetRowCount( self, nCount );
2265 0 : }
2266 0 : SWIGINTERN int GDALRasterAttributeTableShadow_CreateColumn(GDALRasterAttributeTableShadow *self,char const *pszName,GDALRATFieldType eType,GDALRATFieldUsage eUsage){
2267 0 : return GDALRATCreateColumn( self, pszName, eType, eUsage );
2268 : }
2269 0 : SWIGINTERN bool GDALRasterAttributeTableShadow_GetLinearBinning(GDALRasterAttributeTableShadow *self,double *pdfRow0Min,double *pdfBinSize){
2270 0 : return (GDALRATGetLinearBinning(self, pdfRow0Min, pdfBinSize) != 0) ? true : false;
2271 : }
2272 0 : SWIGINTERN int GDALRasterAttributeTableShadow_SetLinearBinning(GDALRasterAttributeTableShadow *self,double dfRow0Min,double dfBinSize){
2273 0 : return GDALRATSetLinearBinning(self, dfRow0Min, dfBinSize);
2274 : }
2275 0 : SWIGINTERN int GDALRasterAttributeTableShadow_GetRowOfValue(GDALRasterAttributeTableShadow *self,double dfValue){
2276 0 : return GDALRATGetRowOfValue( self, dfValue );
2277 : }
2278 0 : SWIGINTERN int GDALRasterAttributeTableShadow_ChangesAreWrittenToFile(GDALRasterAttributeTableShadow *self){
2279 0 : return GDALRATChangesAreWrittenToFile( self );
2280 : }
2281 0 : SWIGINTERN void GDALRasterAttributeTableShadow_DumpReadable(GDALRasterAttributeTableShadow *self){
2282 0 : GDALRATDumpReadable( self, NULL );
2283 0 : }
2284 0 : SWIGINTERN void GDALRasterAttributeTableShadow_SetTableType(GDALRasterAttributeTableShadow *self,GDALRATTableType eTableType){
2285 0 : GDALRATSetTableType( self, eTableType );
2286 0 : }
2287 0 : SWIGINTERN GDALRATTableType GDALRasterAttributeTableShadow_GetTableType(GDALRasterAttributeTableShadow *self){
2288 0 : return GDALRATGetTableType( self );
2289 : }
2290 0 : SWIGINTERN void GDALRasterAttributeTableShadow_RemoveStatistics(GDALRasterAttributeTableShadow *self){
2291 0 : GDALRATRemoveStatistics(self);
2292 0 : }
2293 0 : SWIGINTERN void delete_GDALGroupHS(GDALGroupHS *self){
2294 0 : GDALGroupRelease(self);
2295 0 : }
2296 0 : SWIGINTERN char const *GDALGroupHS_GetName(GDALGroupHS *self){
2297 0 : return GDALGroupGetName(self);
2298 : }
2299 0 : SWIGINTERN char const *GDALGroupHS_GetFullName(GDALGroupHS *self){
2300 0 : return GDALGroupGetFullName(self);
2301 : }
2302 0 : SWIGINTERN char **GDALGroupHS_GetMDArrayNames__SWIG_0(GDALGroupHS *self,char **options=0){
2303 0 : return GDALGroupGetMDArrayNames( self, options );
2304 : }
2305 0 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_OpenMDArray__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2306 :
2307 :
2308 :
2309 0 : GDALMDArrayH hRet = GDALGroupOpenMDArray(self, name, options);
2310 :
2311 :
2312 :
2313 :
2314 0 : return hRet;
2315 : }
2316 0 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_OpenMDArrayFromFullname__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2317 :
2318 :
2319 :
2320 0 : GDALMDArrayH hRet = GDALGroupOpenMDArrayFromFullname(self, name, options);
2321 :
2322 :
2323 :
2324 :
2325 0 : return hRet;
2326 : }
2327 0 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_ResolveMDArray__SWIG_0(GDALGroupHS *self,char const *name,char const *starting_point,char **options=0){
2328 :
2329 :
2330 :
2331 0 : GDALMDArrayH hRet = GDALGroupResolveMDArray(self, name, starting_point, options);
2332 :
2333 :
2334 :
2335 :
2336 0 : return hRet;
2337 : }
2338 0 : SWIGINTERN char **GDALGroupHS_GetGroupNames__SWIG_0(GDALGroupHS *self,char **options=0){
2339 0 : return GDALGroupGetGroupNames( self, options );
2340 : }
2341 0 : SWIGINTERN GDALGroupHS *GDALGroupHS_OpenGroup__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2342 :
2343 :
2344 :
2345 0 : GDALGroupH hRet = GDALGroupOpenGroup(self, name, options);
2346 :
2347 :
2348 :
2349 :
2350 0 : return hRet;
2351 : }
2352 0 : SWIGINTERN GDALGroupHS *GDALGroupHS_OpenGroupFromFullname__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2353 :
2354 :
2355 :
2356 0 : GDALGroupH hRet = GDALGroupOpenGroupFromFullname(self, name, options);
2357 :
2358 :
2359 :
2360 :
2361 0 : return hRet;
2362 : }
2363 0 : SWIGINTERN char **GDALGroupHS_GetVectorLayerNames__SWIG_0(GDALGroupHS *self,char **options=0){
2364 0 : return GDALGroupGetVectorLayerNames( self, options );
2365 : }
2366 0 : SWIGINTERN OGRLayerShadow *GDALGroupHS_OpenVectorLayer__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2367 :
2368 :
2369 :
2370 0 : OGRLayerH hRet = GDALGroupOpenVectorLayer(self, name, options);
2371 :
2372 :
2373 :
2374 :
2375 0 : return (OGRLayerShadow*) hRet;
2376 : }
2377 0 : SWIGINTERN GDALAttributeHS *GDALGroupHS_GetAttribute(GDALGroupHS *self,char const *name){
2378 :
2379 :
2380 :
2381 0 : GDALAttributeH hRet = GDALGroupGetAttribute(self, name);
2382 :
2383 :
2384 :
2385 :
2386 0 : return hRet;
2387 : }
2388 0 : SWIGINTERN char **GDALGroupHS_GetStructuralInfo(GDALGroupHS *self){
2389 0 : return GDALGroupGetStructuralInfo( self );
2390 : }
2391 0 : SWIGINTERN GDALGroupHS *GDALGroupHS_CreateGroup__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2392 0 : return GDALGroupCreateGroup(self, name, options);
2393 : }
2394 0 : SWIGINTERN CPLErr GDALGroupHS_DeleteGroup__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2395 0 : return GDALGroupDeleteGroup(self, name, options) ? CE_None : CE_Failure;
2396 : }
2397 10 : SWIGINTERN GDALDimensionHS *GDALGroupHS_CreateDimension__SWIG_0(GDALGroupHS *self,char const *name,char const *type,char const *direction,GUIntBig size,char **options=0){
2398 10 : return GDALGroupCreateDimension(self, name, type, direction, size, options);
2399 : }
2400 4 : SWIGINTERN GDALMDArrayHS *GDALGroupHS_CreateMDArray__SWIG_0(GDALGroupHS *self,char const *name,int dimensions,GDALDimensionHS **dimensionsValues,GDALExtendedDataTypeHS *data_type,char **options=0){
2401 4 : return GDALGroupCreateMDArray(self, name, dimensions, dimensionsValues,
2402 4 : data_type, options);
2403 : }
2404 0 : SWIGINTERN CPLErr GDALGroupHS_DeleteMDArray__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2405 0 : return GDALGroupDeleteMDArray(self, name, options) ? CE_None : CE_Failure;
2406 : }
2407 0 : SWIGINTERN GDALAttributeHS *GDALGroupHS_CreateAttribute__SWIG_0(GDALGroupHS *self,char const *name,int dimensions,GUIntBig *sizes,GDALExtendedDataTypeHS *data_type,char **options=0){
2408 0 : return GDALGroupCreateAttribute(self, name, dimensions,
2409 : (const GUInt64*) sizes,
2410 0 : data_type, options);
2411 : }
2412 0 : SWIGINTERN CPLErr GDALGroupHS_DeleteAttribute__SWIG_0(GDALGroupHS *self,char const *name,char **options=0){
2413 0 : return GDALGroupDeleteAttribute(self, name, options) ? CE_None : CE_Failure;
2414 : }
2415 0 : SWIGINTERN CPLErr GDALGroupHS_Rename(GDALGroupHS *self,char const *newName){
2416 0 : return GDALGroupRename( self, newName ) ? CE_None : CE_Failure;
2417 : }
2418 0 : SWIGINTERN GDALGroupHS *GDALGroupHS_SubsetDimensionFromSelection__SWIG_0(GDALGroupHS *self,char const *selection,char **options=0){
2419 0 : return GDALGroupSubsetDimensionFromSelection(self, selection, options);
2420 : }
2421 :
2422 : typedef struct
2423 : {
2424 : double min;
2425 : double max;
2426 : double mean;
2427 : double std_dev;
2428 : GIntBig valid_count;
2429 : } Statistics;
2430 :
2431 0 : SWIGINTERN void delete_Statistics(Statistics *self){
2432 0 : CPLFree(self);
2433 0 : }
2434 :
2435 : #include <limits>
2436 :
2437 0 : static bool CheckNumericDataType(GDALExtendedDataTypeHS* dt)
2438 : {
2439 0 : GDALExtendedDataTypeClass klass = GDALExtendedDataTypeGetClass(dt);
2440 0 : if( klass == GEDTC_NUMERIC )
2441 0 : return true;
2442 0 : if( klass == GEDTC_STRING )
2443 0 : return false;
2444 0 : CPLAssert( klass == GEDTC_COMPOUND );
2445 0 : size_t nCount = 0;
2446 0 : GDALEDTComponentH* comps = GDALExtendedDataTypeGetComponents(dt, &nCount);
2447 0 : bool ret = true;
2448 0 : for( size_t i = 0; i < nCount; i++ )
2449 : {
2450 0 : GDALExtendedDataTypeH tmpType = GDALEDTComponentGetType(comps[i]);
2451 0 : ret = CheckNumericDataType(tmpType);
2452 0 : GDALExtendedDataTypeRelease(tmpType);
2453 0 : if( !ret )
2454 0 : break;
2455 : }
2456 0 : GDALExtendedDataTypeFreeComponents(comps, nCount);
2457 0 : return ret;
2458 : }
2459 :
2460 0 : static CPLErr MDArrayReadWriteCheckArguments(GDALMDArrayHS* array,
2461 : bool bCheckOnlyDims,
2462 : int nDims1, GUIntBig* array_start_idx,
2463 : int nDims2, GUIntBig* count,
2464 : int nDims3, GIntBig* array_step,
2465 : int nDims4, GIntBig* buffer_stride,
2466 : GDALExtendedDataTypeHS* buffer_datatype,
2467 : size_t* pnBufferSize)
2468 : {
2469 0 : const int nExpectedDims = (int)GDALMDArrayGetDimensionCount(array);
2470 0 : if( nDims1 != nExpectedDims )
2471 : {
2472 0 : CPLError(CE_Failure, CPLE_AppDefined,
2473 : "Wrong number of values in array_start_idx");
2474 0 : return CE_Failure;
2475 : }
2476 0 : if( nDims2 != nExpectedDims )
2477 : {
2478 0 : CPLError(CE_Failure, CPLE_AppDefined,
2479 : "Wrong number of values in count");
2480 0 : return CE_Failure;
2481 : }
2482 0 : if( nDims3 != nExpectedDims )
2483 : {
2484 0 : CPLError(CE_Failure, CPLE_AppDefined,
2485 : "Wrong number of values in array_step");
2486 0 : return CE_Failure;
2487 : }
2488 0 : if( nDims4!= nExpectedDims )
2489 : {
2490 0 : CPLError(CE_Failure, CPLE_AppDefined,
2491 : "Wrong number of values in buffer_stride");
2492 0 : return CE_Failure;
2493 : }
2494 0 : if( bCheckOnlyDims )
2495 0 : return CE_None;
2496 0 : if( !CheckNumericDataType(buffer_datatype) )
2497 : {
2498 0 : CPLError(CE_Failure, CPLE_NotSupported,
2499 : "non-numeric buffer data type not supported in SWIG bindings");
2500 0 : return CE_Failure;
2501 : }
2502 0 : GIntBig nBufferSize = 0;
2503 0 : for( int i = 0; i < nExpectedDims; i++ )
2504 : {
2505 0 : if( count[i] == 0 )
2506 : {
2507 0 : CPLError(CE_Failure, CPLE_AppDefined,
2508 : "count[%d] = 0 is invalid", i);
2509 0 : return CE_Failure;
2510 : }
2511 0 : if( buffer_stride[i] < 0 )
2512 : {
2513 0 : CPLError(CE_Failure, CPLE_NotSupported,
2514 : "Negative value in buffer_stride not supported in SWIG bindings");
2515 0 : return CE_Failure;
2516 : }
2517 0 : if( count[i] > 1 && buffer_stride[i] != 0 )
2518 : {
2519 0 : if( (GUIntBig)buffer_stride[i] > std::numeric_limits<GIntBig>::max() / (count[i] - 1) )
2520 : {
2521 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
2522 0 : return CE_Failure;
2523 : }
2524 0 : GIntBig nDelta = buffer_stride[i] * (count[i] - 1);
2525 0 : if( nBufferSize > std::numeric_limits<GIntBig>::max() - nDelta )
2526 : {
2527 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
2528 0 : return CE_Failure;
2529 : }
2530 0 : nBufferSize += nDelta;
2531 : }
2532 : }
2533 0 : const size_t nDTSize = GDALExtendedDataTypeGetSize(buffer_datatype);
2534 0 : if( nDTSize == 0 )
2535 : {
2536 0 : CPLError(CE_Failure, CPLE_AppDefined, "nDTSize == 0");
2537 0 : return CE_Failure;
2538 : }
2539 0 : if( (GUIntBig)nBufferSize > (GUIntBig)std::numeric_limits<GIntBig>::max() / nDTSize )
2540 : {
2541 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
2542 0 : return CE_Failure;
2543 : }
2544 0 : nBufferSize *= nDTSize;
2545 0 : if( (GUIntBig)nBufferSize > (GUIntBig)std::numeric_limits<GIntBig>::max() - nDTSize )
2546 : {
2547 0 : CPLError(CE_Failure, CPLE_AppDefined, "Integer overflow");
2548 0 : return CE_Failure;
2549 : }
2550 0 : nBufferSize += nDTSize;
2551 :
2552 : #if SIZEOF_VOIDP == 4
2553 : if( nBufferSize > INT_MAX )
2554 : {
2555 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
2556 : return CE_Failure;
2557 : }
2558 : #endif
2559 0 : *pnBufferSize = (size_t)nBufferSize;
2560 0 : return CE_None;
2561 : }
2562 :
2563 0 : SWIGINTERN void delete_GDALMDArrayHS(GDALMDArrayHS *self){
2564 0 : GDALMDArrayRelease(self);
2565 0 : }
2566 0 : SWIGINTERN char const *GDALMDArrayHS_GetName(GDALMDArrayHS *self){
2567 0 : return GDALMDArrayGetName(self);
2568 : }
2569 0 : SWIGINTERN char const *GDALMDArrayHS_GetFullName(GDALMDArrayHS *self){
2570 0 : return GDALMDArrayGetFullName(self);
2571 : }
2572 0 : SWIGINTERN GUIntBig GDALMDArrayHS_GetTotalElementsCount(GDALMDArrayHS *self){
2573 0 : return GDALMDArrayGetTotalElementsCount(self);
2574 : }
2575 8 : SWIGINTERN size_t GDALMDArrayHS_GetDimensionCount(GDALMDArrayHS *self){
2576 8 : return GDALMDArrayGetDimensionCount(self);
2577 : }
2578 0 : SWIGINTERN GDALExtendedDataTypeHS *GDALMDArrayHS_GetDataType(GDALMDArrayHS *self){
2579 0 : return GDALMDArrayGetDataType(self);
2580 : }
2581 0 : SWIGINTERN char **GDALMDArrayHS_GetStructuralInfo(GDALMDArrayHS *self){
2582 0 : return GDALMDArrayGetStructuralInfo( self );
2583 : }
2584 0 : SWIGINTERN CPLErr GDALMDArrayHS_Resize__SWIG_0(GDALMDArrayHS *self,int newDimensions,GUIntBig *newSizes,char **options=NULL){
2585 0 : if( static_cast<size_t>(newDimensions) != GDALMDArrayGetDimensionCount(self) )
2586 : {
2587 0 : CPLError(CE_Failure, CPLE_IllegalArg,
2588 : "newSizes array not of expected size");
2589 0 : return CE_Failure;
2590 : }
2591 0 : return GDALMDArrayResize( self, newSizes, options ) ? CE_None : CE_Failure;
2592 : }
2593 0 : SWIGINTERN GDALAttributeHS *GDALMDArrayHS_GetAttribute(GDALMDArrayHS *self,char const *name){
2594 :
2595 :
2596 :
2597 0 : GDALAttributeH hRet = GDALMDArrayGetAttribute(self, name);
2598 :
2599 :
2600 :
2601 :
2602 0 : return hRet;
2603 : }
2604 0 : SWIGINTERN GDALAttributeHS *GDALMDArrayHS_CreateAttribute__SWIG_0(GDALMDArrayHS *self,char const *name,int dimensions,GUIntBig *sizes,GDALExtendedDataTypeHS *data_type,char **options=0){
2605 0 : return GDALMDArrayCreateAttribute(self, name, dimensions,
2606 : (const GUInt64*) sizes,
2607 0 : data_type, options);
2608 : }
2609 0 : SWIGINTERN CPLErr GDALMDArrayHS_DeleteAttribute__SWIG_0(GDALMDArrayHS *self,char const *name,char **options=0){
2610 0 : return GDALMDArrayDeleteAttribute(self, name, options) ? CE_None : CE_Failure;
2611 : }
2612 0 : SWIGINTERN void GDALMDArrayHS_GetNoDataValueAsDouble(GDALMDArrayHS *self,double *val,int *hasval){
2613 0 : *val = GDALMDArrayGetNoDataValueAsDouble( self, hasval );
2614 0 : }
2615 0 : SWIGINTERN retStringAndCPLFree *GDALMDArrayHS_GetNoDataValueAsString(GDALMDArrayHS *self){
2616 0 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
2617 0 : const size_t typeClass = GDALExtendedDataTypeGetClass(selfType);
2618 0 : GDALExtendedDataTypeRelease(selfType);
2619 :
2620 0 : if( typeClass != GEDTC_STRING )
2621 : {
2622 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Data type is not string");
2623 0 : return NULL;
2624 : }
2625 0 : const void* pabyBuf = GDALMDArrayGetRawNoDataValue(self);
2626 0 : if( pabyBuf == NULL )
2627 : {
2628 0 : return NULL;
2629 : }
2630 0 : const char* ret = *reinterpret_cast<const char* const*>(pabyBuf);
2631 0 : if( ret )
2632 0 : return CPLStrdup(ret);
2633 0 : return NULL;
2634 : }
2635 0 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueDouble(GDALMDArrayHS *self,double d){
2636 0 : return GDALMDArraySetNoDataValueAsDouble( self, d ) ? CE_None : CE_Failure;
2637 : }
2638 0 : SWIGINTERN CPLErr GDALMDArrayHS_SetNoDataValueString(GDALMDArrayHS *self,char const *nodata){
2639 0 : GDALExtendedDataTypeHS* selfType = GDALMDArrayGetDataType(self);
2640 0 : const size_t typeClass = GDALExtendedDataTypeGetClass(selfType);
2641 0 : GDALExtendedDataTypeRelease(selfType);
2642 :
2643 0 : if( typeClass != GEDTC_STRING )
2644 : {
2645 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Data type is not string");
2646 0 : return CE_Failure;
2647 : }
2648 0 : return GDALMDArraySetRawNoDataValue(self, &nodata) ? CE_None : CE_Failure;
2649 : }
2650 0 : SWIGINTERN CPLErr GDALMDArrayHS_DeleteNoDataValue(GDALMDArrayHS *self){
2651 0 : return GDALMDArraySetRawNoDataValue( self, NULL ) ? CE_None : CE_Failure;
2652 : }
2653 0 : SWIGINTERN void GDALMDArrayHS_GetOffset(GDALMDArrayHS *self,double *val,int *hasval){
2654 0 : *val = GDALMDArrayGetOffset( self, hasval );
2655 0 : }
2656 0 : SWIGINTERN GDALDataType GDALMDArrayHS_GetOffsetStorageType(GDALMDArrayHS *self){
2657 0 : GDALDataType eDT = GDT_Unknown;
2658 0 : int hasval = FALSE;
2659 0 : GDALMDArrayGetOffsetEx( self, &hasval, &eDT );
2660 0 : return hasval ? eDT : GDT_Unknown;
2661 : }
2662 0 : SWIGINTERN void GDALMDArrayHS_GetScale(GDALMDArrayHS *self,double *val,int *hasval){
2663 0 : *val = GDALMDArrayGetScale( self, hasval );
2664 0 : }
2665 0 : SWIGINTERN GDALDataType GDALMDArrayHS_GetScaleStorageType(GDALMDArrayHS *self){
2666 0 : GDALDataType eDT = GDT_Unknown;
2667 0 : int hasval = FALSE;
2668 0 : GDALMDArrayGetScaleEx( self, &hasval, &eDT );
2669 0 : return hasval ? eDT : GDT_Unknown;
2670 : }
2671 0 : SWIGINTERN CPLErr GDALMDArrayHS_SetOffset__SWIG_0(GDALMDArrayHS *self,double val,GDALDataType storageType=GDT_Unknown){
2672 0 : return GDALMDArraySetOffsetEx( self, val, storageType ) ? CE_None : CE_Failure;
2673 : }
2674 0 : SWIGINTERN CPLErr GDALMDArrayHS_SetScale__SWIG_0(GDALMDArrayHS *self,double val,GDALDataType storageType=GDT_Unknown){
2675 0 : return GDALMDArraySetScaleEx( self, val, storageType ) ? CE_None : CE_Failure;
2676 : }
2677 0 : SWIGINTERN CPLErr GDALMDArrayHS_SetUnit(GDALMDArrayHS *self,char const *unit){
2678 0 : return GDALMDArraySetUnit(self, unit) ? CE_None : CE_Failure;
2679 : }
2680 0 : SWIGINTERN char const *GDALMDArrayHS_GetUnit(GDALMDArrayHS *self){
2681 0 : return GDALMDArrayGetUnit(self);
2682 : }
2683 0 : SWIGINTERN OGRErr GDALMDArrayHS_SetSpatialRef(GDALMDArrayHS *self,OSRSpatialReferenceShadow *srs){
2684 0 : return GDALMDArraySetSpatialRef( self, (OGRSpatialReferenceH)srs ) ? CE_None : CE_Failure;
2685 : }
2686 0 : SWIGINTERN OSRSpatialReferenceShadow *GDALMDArrayHS_GetSpatialRef(GDALMDArrayHS *self){
2687 0 : return GDALMDArrayGetSpatialRef(self);
2688 : }
2689 0 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetView(GDALMDArrayHS *self,char const *viewExpr){
2690 0 : return GDALMDArrayGetView(self, viewExpr);
2691 : }
2692 0 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_Transpose(GDALMDArrayHS *self,int axisMap,int *mapInts){
2693 0 : return GDALMDArrayTranspose(self, axisMap, mapInts);
2694 : }
2695 0 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetUnscaled(GDALMDArrayHS *self){
2696 0 : return GDALMDArrayGetUnscaled(self);
2697 : }
2698 0 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetMask__SWIG_0(GDALMDArrayHS *self,char **options=0){
2699 0 : return GDALMDArrayGetMask(self, options);
2700 : }
2701 0 : SWIGINTERN GDALMDArrayHS *GDALMDArrayHS_GetGridded__SWIG_0(GDALMDArrayHS *self,char const *pszGridOptions,GDALMDArrayHS *xArray=NULL,GDALMDArrayHS *yArray=NULL,char **options=0){
2702 0 : return GDALMDArrayGetGridded(self, pszGridOptions, xArray, yArray, options);
2703 : }
2704 0 : SWIGINTERN GDALDatasetShadow *GDALMDArrayHS_AsClassicDataset__SWIG_0(GDALMDArrayHS *self,size_t iXDim,size_t iYDim,GDALGroupHS *hRootGroup=NULL,char **options=0){
2705 0 : return (GDALDatasetShadow*)GDALMDArrayAsClassicDatasetEx(self, iXDim, iYDim, hRootGroup, options);
2706 : }
2707 0 : SWIGINTERN Statistics *GDALMDArrayHS_GetStatistics__SWIG_0(GDALMDArrayHS *self,bool approx_ok=FALSE,bool force=TRUE,GDALProgressFunc callback=NULL,void *callback_data=NULL){
2708 0 : GUInt64 nValidCount = 0;
2709 0 : Statistics* psStatisticsOut = (Statistics*)CPLMalloc(sizeof(Statistics));
2710 0 : CPLErr eErr = GDALMDArrayGetStatistics(self, NULL, approx_ok, force,
2711 : &(psStatisticsOut->min),
2712 : &(psStatisticsOut->max),
2713 : &(psStatisticsOut->mean),
2714 : &(psStatisticsOut->std_dev),
2715 : &nValidCount,
2716 : callback, callback_data);
2717 0 : psStatisticsOut->valid_count = static_cast<GIntBig>(nValidCount);
2718 0 : if( eErr == CE_None )
2719 0 : return psStatisticsOut;
2720 0 : CPLFree(psStatisticsOut);
2721 0 : return NULL;
2722 : }
2723 0 : SWIGINTERN Statistics *GDALMDArrayHS_ComputeStatistics__SWIG_0(GDALMDArrayHS *self,bool approx_ok=FALSE,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=0){
2724 0 : GUInt64 nValidCount = 0;
2725 0 : Statistics* psStatisticsOut = (Statistics*)CPLMalloc(sizeof(Statistics));
2726 0 : int nSuccess = GDALMDArrayComputeStatisticsEx(self, NULL, approx_ok,
2727 : &(psStatisticsOut->min),
2728 : &(psStatisticsOut->max),
2729 : &(psStatisticsOut->mean),
2730 : &(psStatisticsOut->std_dev),
2731 : &nValidCount,
2732 : callback, callback_data, options);
2733 0 : psStatisticsOut->valid_count = static_cast<GIntBig>(nValidCount);
2734 0 : if( nSuccess )
2735 0 : return psStatisticsOut;
2736 0 : CPLFree(psStatisticsOut);
2737 0 : return NULL;
2738 : }
2739 0 : SWIGINTERN bool GDALMDArrayHS_Cache__SWIG_0(GDALMDArrayHS *self,char **options=NULL){
2740 0 : return GDALMDArrayCache(self, options);
2741 : }
2742 0 : SWIGINTERN CPLErr GDALMDArrayHS_Rename(GDALMDArrayHS *self,char const *newName){
2743 0 : return GDALMDArrayRename( self, newName ) ? CE_None : CE_Failure;
2744 : }
2745 20 : SWIGINTERN GDALDimensionHS *GDALMDArrayHS_GetDimension(GDALMDArrayHS *self,size_t index){
2746 20 : return GDALMDArrayGetDim(self, index);
2747 : }
2748 0 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_0(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,char *arrayOut,size_t arraySize){
2749 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2750 :
2751 0 : if (starts != numDims ||
2752 0 : counts != numDims ||
2753 0 : steps != numDims ||
2754 0 : strides != numDims)
2755 : {
2756 0 : return false;
2757 : }
2758 :
2759 : GDALExtendedDataTypeH buffer_type =
2760 0 : GDALExtendedDataTypeCreate(GDT_Byte);
2761 :
2762 : bool result =
2763 0 : MDArrayRead(self,
2764 : counts,
2765 : startsValues,
2766 : countsValues,
2767 : stepsValues,
2768 : stridesValues,
2769 : arrayOut,
2770 : arraySize,
2771 : buffer_type);
2772 :
2773 0 : GDALExtendedDataTypeRelease(buffer_type);
2774 :
2775 0 : return result;
2776 : }
2777 18 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_1(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,short *arrayOut,size_t arraySize){
2778 18 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2779 :
2780 18 : if (starts != numDims ||
2781 18 : counts != numDims ||
2782 18 : steps != numDims ||
2783 18 : strides != numDims)
2784 : {
2785 0 : return false;
2786 : }
2787 :
2788 : GDALExtendedDataTypeH buffer_type =
2789 18 : GDALExtendedDataTypeCreate(GDT_Int16);
2790 :
2791 : bool result =
2792 18 : MDArrayRead(self,
2793 : counts,
2794 : startsValues,
2795 : countsValues,
2796 : stepsValues,
2797 : stridesValues,
2798 : arrayOut,
2799 : arraySize,
2800 : buffer_type);
2801 :
2802 18 : GDALExtendedDataTypeRelease(buffer_type);
2803 :
2804 18 : return result;
2805 : }
2806 0 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_2(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,int *arrayOut,size_t arraySize){
2807 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2808 :
2809 0 : if (starts != numDims ||
2810 0 : counts != numDims ||
2811 0 : steps != numDims ||
2812 0 : strides != numDims)
2813 : {
2814 0 : return false;
2815 : }
2816 :
2817 : GDALExtendedDataTypeH buffer_type =
2818 0 : GDALExtendedDataTypeCreate(GDT_Int32);
2819 :
2820 : bool result =
2821 0 : MDArrayRead(self,
2822 : counts,
2823 : startsValues,
2824 : countsValues,
2825 : stepsValues,
2826 : stridesValues,
2827 : arrayOut,
2828 : arraySize,
2829 : buffer_type);
2830 :
2831 0 : GDALExtendedDataTypeRelease(buffer_type);
2832 :
2833 0 : return result;
2834 : }
2835 0 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_3(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,int64_t *arrayOut,size_t arraySize){
2836 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2837 :
2838 0 : if (starts != numDims ||
2839 0 : counts != numDims ||
2840 0 : steps != numDims ||
2841 0 : strides != numDims)
2842 : {
2843 0 : return false;
2844 : }
2845 :
2846 : GDALExtendedDataTypeH buffer_type =
2847 0 : GDALExtendedDataTypeCreate(GDT_Int64);
2848 :
2849 : bool result =
2850 0 : MDArrayRead(self,
2851 : counts,
2852 : startsValues,
2853 : countsValues,
2854 : stepsValues,
2855 : stridesValues,
2856 : arrayOut,
2857 : arraySize,
2858 : buffer_type);
2859 :
2860 0 : GDALExtendedDataTypeRelease(buffer_type);
2861 :
2862 0 : return result;
2863 : }
2864 0 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_4(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,float *arrayOut,size_t arraySize){
2865 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2866 :
2867 0 : if (starts != numDims ||
2868 0 : counts != numDims ||
2869 0 : steps != numDims ||
2870 0 : strides != numDims)
2871 : {
2872 0 : return false;
2873 : }
2874 :
2875 : GDALExtendedDataTypeH buffer_type =
2876 0 : GDALExtendedDataTypeCreate(GDT_Float32);
2877 :
2878 : bool result =
2879 0 : MDArrayRead(self,
2880 : counts,
2881 : startsValues,
2882 : countsValues,
2883 : stepsValues,
2884 : stridesValues,
2885 : arrayOut,
2886 : arraySize,
2887 : buffer_type);
2888 :
2889 0 : GDALExtendedDataTypeRelease(buffer_type);
2890 :
2891 0 : return result;
2892 : }
2893 0 : SWIGINTERN bool GDALMDArrayHS_Read__SWIG_5(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,double *arrayOut,size_t arraySize){
2894 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2895 :
2896 0 : if (starts != numDims ||
2897 0 : counts != numDims ||
2898 0 : steps != numDims ||
2899 0 : strides != numDims)
2900 : {
2901 0 : return false;
2902 : }
2903 :
2904 : GDALExtendedDataTypeH buffer_type =
2905 0 : GDALExtendedDataTypeCreate(GDT_Float64);
2906 :
2907 : bool result =
2908 0 : MDArrayRead(self,
2909 : counts,
2910 : startsValues,
2911 : countsValues,
2912 : stepsValues,
2913 : stridesValues,
2914 : arrayOut,
2915 : arraySize,
2916 : buffer_type);
2917 :
2918 0 : GDALExtendedDataTypeRelease(buffer_type);
2919 :
2920 0 : return result;
2921 : }
2922 0 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_0(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,char *arrayIn,size_t arraySize){
2923 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2924 :
2925 0 : if (starts != numDims ||
2926 0 : counts != numDims ||
2927 0 : steps != numDims ||
2928 0 : strides != numDims)
2929 : {
2930 0 : return false;
2931 : }
2932 :
2933 : GDALExtendedDataTypeH buffer_type =
2934 0 : GDALExtendedDataTypeCreate(GDT_Byte);
2935 :
2936 : bool result =
2937 0 : MDArrayWrite(self,
2938 : counts,
2939 : startsValues,
2940 : countsValues,
2941 : stepsValues,
2942 : stridesValues,
2943 : arrayIn,
2944 : arraySize,
2945 : buffer_type);
2946 :
2947 0 : GDALExtendedDataTypeRelease(buffer_type);
2948 :
2949 0 : return result;
2950 : }
2951 18 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_1(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,short *arrayIn,size_t arraySize){
2952 18 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2953 :
2954 18 : if (starts != numDims ||
2955 18 : counts != numDims ||
2956 18 : steps != numDims ||
2957 18 : strides != numDims)
2958 : {
2959 0 : return false;
2960 : }
2961 :
2962 : GDALExtendedDataTypeH buffer_type =
2963 18 : GDALExtendedDataTypeCreate(GDT_Int16);
2964 :
2965 : bool result =
2966 18 : MDArrayWrite(self,
2967 : counts,
2968 : startsValues,
2969 : countsValues,
2970 : stepsValues,
2971 : stridesValues,
2972 : arrayIn,
2973 : arraySize,
2974 : buffer_type);
2975 :
2976 18 : GDALExtendedDataTypeRelease(buffer_type);
2977 :
2978 18 : return result;
2979 : }
2980 0 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_2(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,int *arrayIn,size_t arraySize){
2981 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
2982 :
2983 0 : if (starts != numDims ||
2984 0 : counts != numDims ||
2985 0 : steps != numDims ||
2986 0 : strides != numDims)
2987 : {
2988 0 : return false;
2989 : }
2990 :
2991 : GDALExtendedDataTypeH buffer_type =
2992 0 : GDALExtendedDataTypeCreate(GDT_Int32);
2993 :
2994 : bool result =
2995 0 : MDArrayWrite(self,
2996 : counts,
2997 : startsValues,
2998 : countsValues,
2999 : stepsValues,
3000 : stridesValues,
3001 : arrayIn,
3002 : arraySize,
3003 : buffer_type);
3004 :
3005 0 : GDALExtendedDataTypeRelease(buffer_type);
3006 :
3007 0 : return result;
3008 : }
3009 0 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_3(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,int64_t *arrayIn,size_t arraySize){
3010 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
3011 :
3012 0 : if (starts != numDims ||
3013 0 : counts != numDims ||
3014 0 : steps != numDims ||
3015 0 : strides != numDims)
3016 : {
3017 0 : return false;
3018 : }
3019 :
3020 : GDALExtendedDataTypeH buffer_type =
3021 0 : GDALExtendedDataTypeCreate(GDT_Int64);
3022 :
3023 : bool result =
3024 0 : MDArrayWrite(self,
3025 : counts,
3026 : startsValues,
3027 : countsValues,
3028 : stepsValues,
3029 : stridesValues,
3030 : arrayIn,
3031 : arraySize,
3032 : buffer_type);
3033 :
3034 0 : GDALExtendedDataTypeRelease(buffer_type);
3035 :
3036 0 : return result;
3037 : }
3038 0 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_4(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,float *arrayIn,size_t arraySize){
3039 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
3040 :
3041 0 : if (starts != numDims ||
3042 0 : counts != numDims ||
3043 0 : steps != numDims ||
3044 0 : strides != numDims)
3045 : {
3046 0 : return false;
3047 : }
3048 :
3049 : GDALExtendedDataTypeH buffer_type =
3050 0 : GDALExtendedDataTypeCreate(GDT_Float32);
3051 :
3052 : bool result =
3053 0 : MDArrayWrite(self,
3054 : counts,
3055 : startsValues,
3056 : countsValues,
3057 : stepsValues,
3058 : stridesValues,
3059 : arrayIn,
3060 : arraySize,
3061 : buffer_type);
3062 :
3063 0 : GDALExtendedDataTypeRelease(buffer_type);
3064 :
3065 0 : return result;
3066 : }
3067 0 : SWIGINTERN bool GDALMDArrayHS_Write__SWIG_5(GDALMDArrayHS *self,int starts,GInt64 *startsValues,int counts,GInt64 *countsValues,int steps,GInt64 *stepsValues,int strides,GInt64 *stridesValues,double *arrayIn,size_t arraySize){
3068 0 : size_t numDims = GDALMDArrayGetDimensionCount(self);
3069 :
3070 0 : if (starts != numDims ||
3071 0 : counts != numDims ||
3072 0 : steps != numDims ||
3073 0 : strides != numDims)
3074 : {
3075 0 : return false;
3076 : }
3077 :
3078 : GDALExtendedDataTypeH buffer_type =
3079 0 : GDALExtendedDataTypeCreate(GDT_Float64);
3080 :
3081 : bool result =
3082 0 : MDArrayWrite(self,
3083 : counts,
3084 : startsValues,
3085 : countsValues,
3086 : stepsValues,
3087 : stridesValues,
3088 : arrayIn,
3089 : arraySize,
3090 : buffer_type);
3091 :
3092 0 : GDALExtendedDataTypeRelease(buffer_type);
3093 :
3094 0 : return result;
3095 : }
3096 0 : SWIGINTERN void delete_GDALAttributeHS(GDALAttributeHS *self){
3097 0 : GDALAttributeRelease(self);
3098 0 : }
3099 0 : SWIGINTERN char const *GDALAttributeHS_GetName(GDALAttributeHS *self){
3100 0 : return GDALAttributeGetName(self);
3101 : }
3102 0 : SWIGINTERN char const *GDALAttributeHS_GetFullName(GDALAttributeHS *self){
3103 0 : return GDALAttributeGetFullName(self);
3104 : }
3105 0 : SWIGINTERN GUIntBig GDALAttributeHS_GetTotalElementsCount(GDALAttributeHS *self){
3106 0 : return GDALAttributeGetTotalElementsCount(self);
3107 : }
3108 0 : SWIGINTERN size_t GDALAttributeHS_GetDimensionCount(GDALAttributeHS *self){
3109 0 : return GDALAttributeGetDimensionCount(self);
3110 : }
3111 0 : SWIGINTERN GDALExtendedDataTypeHS *GDALAttributeHS_GetDataType(GDALAttributeHS *self){
3112 0 : return GDALAttributeGetDataType(self);
3113 : }
3114 0 : SWIGINTERN char const *GDALAttributeHS_ReadAsString(GDALAttributeHS *self){
3115 0 : return GDALAttributeReadAsString(self);
3116 : }
3117 0 : SWIGINTERN int GDALAttributeHS_ReadAsInt(GDALAttributeHS *self){
3118 0 : return GDALAttributeReadAsInt(self);
3119 : }
3120 0 : SWIGINTERN double GDALAttributeHS_ReadAsDouble(GDALAttributeHS *self){
3121 0 : return GDALAttributeReadAsDouble(self);
3122 : }
3123 0 : SWIGINTERN char **GDALAttributeHS_ReadAsStringArray(GDALAttributeHS *self){
3124 0 : return GDALAttributeReadAsStringArray(self);
3125 : }
3126 0 : SWIGINTERN CPLErr GDALAttributeHS_WriteString(GDALAttributeHS *self,char const *val){
3127 0 : return GDALAttributeWriteString(self, val) ? CE_None : CE_Failure;
3128 : }
3129 0 : SWIGINTERN CPLErr GDALAttributeHS_WriteStringArray(GDALAttributeHS *self,char **vals){
3130 0 : return GDALAttributeWriteStringArray(self, vals) ? CE_None : CE_Failure;
3131 : }
3132 0 : SWIGINTERN CPLErr GDALAttributeHS_WriteInt(GDALAttributeHS *self,int val){
3133 0 : return GDALAttributeWriteInt(self, val) ? CE_None : CE_Failure;
3134 : }
3135 0 : SWIGINTERN CPLErr GDALAttributeHS_WriteDouble(GDALAttributeHS *self,double val){
3136 0 : return GDALAttributeWriteDouble(self, val) ? CE_None : CE_Failure;
3137 : }
3138 0 : SWIGINTERN CPLErr GDALAttributeHS_Rename(GDALAttributeHS *self,char const *newName){
3139 0 : return GDALAttributeRename( self, newName ) ? CE_None : CE_Failure;
3140 : }
3141 0 : SWIGINTERN size_t GDALAttributeHS_GetDimensionSize(GDALAttributeHS *self,size_t index){
3142 0 : return GDALAttributeGetDimSize(self, index);
3143 : }
3144 0 : SWIGINTERN void delete_GDALDimensionHS(GDALDimensionHS *self){
3145 0 : GDALDimensionRelease(self);
3146 0 : }
3147 10 : SWIGINTERN char const *GDALDimensionHS_GetName(GDALDimensionHS *self){
3148 10 : return GDALDimensionGetName(self);
3149 : }
3150 0 : SWIGINTERN char const *GDALDimensionHS_GetFullName(GDALDimensionHS *self){
3151 0 : return GDALDimensionGetFullName(self);
3152 : }
3153 10 : SWIGINTERN char const *GDALDimensionHS_GetType(GDALDimensionHS *self){
3154 10 : return GDALDimensionGetType(self);
3155 : }
3156 10 : SWIGINTERN char const *GDALDimensionHS_GetDirection(GDALDimensionHS *self){
3157 10 : return GDALDimensionGetDirection(self);
3158 : }
3159 10 : SWIGINTERN GUIntBig GDALDimensionHS_GetSize(GDALDimensionHS *self){
3160 10 : return GDALDimensionGetSize(self);
3161 : }
3162 0 : SWIGINTERN GDALMDArrayHS *GDALDimensionHS_GetIndexingVariable(GDALDimensionHS *self){
3163 0 : return GDALDimensionGetIndexingVariable(self);
3164 : }
3165 0 : SWIGINTERN bool GDALDimensionHS_SetIndexingVariable(GDALDimensionHS *self,GDALMDArrayHS *array){
3166 0 : return GDALDimensionSetIndexingVariable(self, array);
3167 : }
3168 0 : SWIGINTERN CPLErr GDALDimensionHS_Rename(GDALDimensionHS *self,char const *newName){
3169 0 : return GDALDimensionRename( self, newName ) ? CE_None : CE_Failure;
3170 : }
3171 0 : SWIGINTERN void delete_GDALExtendedDataTypeHS(GDALExtendedDataTypeHS *self){
3172 0 : GDALExtendedDataTypeRelease(self);
3173 0 : }
3174 4 : SWIGINTERN GDALExtendedDataTypeHS *GDALExtendedDataTypeHS_Create(GDALDataType dt){
3175 4 : return GDALExtendedDataTypeCreate(dt);
3176 : }
3177 0 : SWIGINTERN GDALExtendedDataTypeHS *GDALExtendedDataTypeHS_CreateString__SWIG_0(size_t nMaxStringLength=0,GDALExtendedDataTypeSubType eSubType=GEDTST_NONE){
3178 0 : return GDALExtendedDataTypeCreateStringEx(nMaxStringLength, eSubType);
3179 : }
3180 0 : SWIGINTERN char const *GDALExtendedDataTypeHS_GetName(GDALExtendedDataTypeHS *self){
3181 0 : return GDALExtendedDataTypeGetName(self);
3182 : }
3183 0 : SWIGINTERN GDALExtendedDataTypeClass GDALExtendedDataTypeHS_GetClass(GDALExtendedDataTypeHS *self){
3184 0 : return GDALExtendedDataTypeGetClass(self);
3185 : }
3186 0 : SWIGINTERN GDALDataType GDALExtendedDataTypeHS_GetNumericDataType(GDALExtendedDataTypeHS *self){
3187 0 : return GDALExtendedDataTypeGetNumericDataType(self);
3188 : }
3189 0 : SWIGINTERN size_t GDALExtendedDataTypeHS_GetSize(GDALExtendedDataTypeHS *self){
3190 0 : return GDALExtendedDataTypeGetSize(self);
3191 : }
3192 0 : SWIGINTERN size_t GDALExtendedDataTypeHS_GetMaxStringLength(GDALExtendedDataTypeHS *self){
3193 0 : return GDALExtendedDataTypeGetMaxStringLength(self);
3194 : }
3195 0 : SWIGINTERN GDALExtendedDataTypeSubType GDALExtendedDataTypeHS_GetSubType(GDALExtendedDataTypeHS *self){
3196 0 : return GDALExtendedDataTypeGetSubType(self);
3197 : }
3198 0 : SWIGINTERN bool GDALExtendedDataTypeHS_CanConvertTo(GDALExtendedDataTypeHS *self,GDALExtendedDataTypeHS *other){
3199 0 : return GDALExtendedDataTypeCanConvertTo(self, other);
3200 : }
3201 0 : SWIGINTERN bool GDALExtendedDataTypeHS_Equals(GDALExtendedDataTypeHS *self,GDALExtendedDataTypeHS *other){
3202 0 : return GDALExtendedDataTypeEquals(self, other);
3203 : }
3204 0 : SWIGINTERN void delete_GDALEDTComponentHS(GDALEDTComponentHS *self){
3205 0 : GDALEDTComponentRelease(self);
3206 0 : }
3207 0 : SWIGINTERN GDALEDTComponentHS *GDALEDTComponentHS_Create(char const *name,size_t offset,GDALExtendedDataTypeHS *type){
3208 0 : return GDALEDTComponentCreate(name, offset, type);
3209 : }
3210 0 : SWIGINTERN char const *GDALEDTComponentHS_GetName(GDALEDTComponentHS *self){
3211 0 : return GDALEDTComponentGetName(self);
3212 : }
3213 0 : SWIGINTERN size_t GDALEDTComponentHS_GetOffset(GDALEDTComponentHS *self){
3214 0 : return GDALEDTComponentGetOffset(self);
3215 : }
3216 0 : SWIGINTERN GDALExtendedDataTypeHS *GDALEDTComponentHS_GetType(GDALEDTComponentHS *self){
3217 0 : return GDALEDTComponentGetType(self);
3218 : }
3219 :
3220 : /* Returned size is in bytes or 0 if an error occurred. */
3221 : static
3222 79975 : GIntBig ComputeBandRasterIOSize (int buf_xsize, int buf_ysize, int nPixelSize,
3223 : GIntBig nPixelSpace, GIntBig nLineSpace,
3224 : int bSpacingShouldBeMultipleOfPixelSize )
3225 : {
3226 79975 : if (buf_xsize <= 0 || buf_ysize <= 0)
3227 : {
3228 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for buffer size");
3229 0 : return 0;
3230 : }
3231 :
3232 79977 : if (nPixelSpace < 0 || nLineSpace < 0)
3233 : {
3234 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal values for space arguments");
3235 0 : return 0;
3236 : }
3237 :
3238 79978 : if (nPixelSize == 0)
3239 : {
3240 0 : CPLError(CE_Failure, CPLE_IllegalArg, "Illegal value for data type");
3241 0 : return 0;
3242 : }
3243 :
3244 79978 : if( nPixelSpace == 0 )
3245 79983 : nPixelSpace = nPixelSize;
3246 0 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nPixelSpace % nPixelSize) != 0 )
3247 : {
3248 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nPixelSpace should be a multiple of nPixelSize");
3249 0 : return 0;
3250 : }
3251 :
3252 79978 : if( nLineSpace == 0 )
3253 : {
3254 79975 : nLineSpace = nPixelSpace * buf_xsize;
3255 : }
3256 3 : else if ( bSpacingShouldBeMultipleOfPixelSize && (nLineSpace % nPixelSize) != 0 )
3257 : {
3258 0 : CPLError(CE_Failure, CPLE_IllegalArg, "nLineSpace should be a multiple of nPixelSize");
3259 0 : return 0;
3260 : }
3261 :
3262 79978 : GIntBig nRet = (GIntBig)(buf_ysize - 1) * nLineSpace + (GIntBig)(buf_xsize - 1) * nPixelSpace + nPixelSize;
3263 : #if SIZEOF_VOIDP == 4
3264 : if (nRet > INT_MAX)
3265 : {
3266 : CPLError(CE_Failure, CPLE_IllegalArg, "Integer overflow");
3267 : return 0;
3268 : }
3269 : #endif
3270 :
3271 79978 : return nRet;
3272 : }
3273 :
3274 0 : SWIGINTERN GDALDatasetShadow *GDALRasterBandShadow_GetDataset(GDALRasterBandShadow *self){
3275 0 : return (GDALDatasetShadow*) GDALGetBandDataset(self);
3276 : }
3277 0 : SWIGINTERN int GDALRasterBandShadow_GetBand(GDALRasterBandShadow *self){
3278 0 : return GDALGetBandNumber(self);
3279 : }
3280 1 : SWIGINTERN void GDALRasterBandShadow_GetBlockSize(GDALRasterBandShadow *self,int *pnBlockXSize,int *pnBlockYSize){
3281 1 : GDALGetBlockSize(self, pnBlockXSize, pnBlockYSize);
3282 1 : }
3283 0 : SWIGINTERN GDALColorInterp GDALRasterBandShadow_GetColorInterpretation(GDALRasterBandShadow *self){
3284 0 : return GDALGetRasterColorInterpretation(self);
3285 : }
3286 5 : SWIGINTERN GDALColorInterp GDALRasterBandShadow_GetRasterColorInterpretation(GDALRasterBandShadow *self){
3287 5 : return GDALGetRasterColorInterpretation(self);
3288 : }
3289 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetColorInterpretation(GDALRasterBandShadow *self,GDALColorInterp val){
3290 0 : return GDALSetRasterColorInterpretation( self, val );
3291 : }
3292 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetRasterColorInterpretation(GDALRasterBandShadow *self,GDALColorInterp val){
3293 0 : return GDALSetRasterColorInterpretation( self, val );
3294 : }
3295 2 : SWIGINTERN void GDALRasterBandShadow_GetNoDataValue(GDALRasterBandShadow *self,double *val,int *hasval){
3296 2 : *val = GDALGetRasterNoDataValue( self, hasval );
3297 2 : }
3298 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetNoDataValue(GDALRasterBandShadow *self,double d){
3299 0 : return GDALSetRasterNoDataValue( self, d );
3300 : }
3301 0 : SWIGINTERN CPLErr GDALRasterBandShadow_DeleteNoDataValue(GDALRasterBandShadow *self){
3302 0 : return GDALDeleteRasterNoDataValue(self);
3303 : }
3304 2 : SWIGINTERN char const *GDALRasterBandShadow_GetUnitType(GDALRasterBandShadow *self){
3305 2 : return GDALGetRasterUnitType(self);
3306 : }
3307 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetUnitType(GDALRasterBandShadow *self,char const *val){
3308 0 : return GDALSetRasterUnitType( self, val );
3309 : }
3310 1 : SWIGINTERN char **GDALRasterBandShadow_GetRasterCategoryNames(GDALRasterBandShadow *self){
3311 1 : return GDALGetRasterCategoryNames(self);
3312 : }
3313 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetRasterCategoryNames(GDALRasterBandShadow *self,char **names){
3314 0 : return GDALSetRasterCategoryNames( self, names );
3315 : }
3316 1 : SWIGINTERN void GDALRasterBandShadow_GetMinimum(GDALRasterBandShadow *self,double *val,int *hasval){
3317 1 : *val = GDALGetRasterMinimum( self, hasval );
3318 1 : }
3319 1 : SWIGINTERN void GDALRasterBandShadow_GetMaximum(GDALRasterBandShadow *self,double *val,int *hasval){
3320 1 : *val = GDALGetRasterMaximum( self, hasval );
3321 1 : }
3322 1 : SWIGINTERN void GDALRasterBandShadow_GetOffset(GDALRasterBandShadow *self,double *val,int *hasval){
3323 1 : *val = GDALGetRasterOffset( self, hasval );
3324 1 : }
3325 1 : SWIGINTERN void GDALRasterBandShadow_GetScale(GDALRasterBandShadow *self,double *val,int *hasval){
3326 1 : *val = GDALGetRasterScale( self, hasval );
3327 1 : }
3328 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetOffset(GDALRasterBandShadow *self,double val){
3329 0 : return GDALSetRasterOffset( self, val );
3330 : }
3331 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetScale(GDALRasterBandShadow *self,double val){
3332 0 : return GDALSetRasterScale( self, val );
3333 : }
3334 1 : SWIGINTERN CPLErr GDALRasterBandShadow_GetStatistics(GDALRasterBandShadow *self,int approx_ok,int force,double *min,double *max,double *mean,double *stddev){
3335 1 : if (min) *min = 0;
3336 1 : if (max) *max = 0;
3337 1 : if (mean) *mean = 0;
3338 1 : if (stddev) *stddev = -1; /* This is the only way to recognize from Python if GetRasterStatistics() has updated the values */
3339 1 : return GDALGetRasterStatistics( self, approx_ok, force,
3340 1 : min, max, mean, stddev );
3341 : }
3342 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ComputeStatistics__SWIG_0(GDALRasterBandShadow *self,bool approx_ok,double *min,double *max,double *mean,double *stddev,GDALProgressFunc callback=NULL,void *callback_data=NULL){
3343 0 : return GDALComputeRasterStatistics( self, approx_ok, min, max, mean, stddev, callback, callback_data );
3344 : }
3345 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetStatistics(GDALRasterBandShadow *self,double min,double max,double mean,double stddev){
3346 0 : return GDALSetRasterStatistics( self, min, max, mean, stddev );
3347 : }
3348 10 : SWIGINTERN int GDALRasterBandShadow_GetOverviewCount(GDALRasterBandShadow *self){
3349 10 : return GDALGetOverviewCount(self);
3350 : }
3351 6 : SWIGINTERN GDALRasterBandShadow *GDALRasterBandShadow_GetOverview(GDALRasterBandShadow *self,int i){
3352 6 : return (GDALRasterBandShadow*) GDALGetOverview( self, i );
3353 : }
3354 3 : SWIGINTERN int GDALRasterBandShadow_Checksum(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize){
3355 3 : return GDALChecksumImage( self, xoff, yoff, xsize, ysize );
3356 : }
3357 0 : SWIGINTERN void GDALRasterBandShadow_ComputeRasterMinMax__SWIG_0(GDALRasterBandShadow *self,double argout[2],int approx_ok=0){
3358 0 : GDALComputeRasterMinMax( self, approx_ok, argout );
3359 0 : }
3360 0 : SWIGINTERN void GDALRasterBandShadow_ComputeBandStats__SWIG_0(GDALRasterBandShadow *self,double argout[2],int samplestep=1){
3361 0 : GDALComputeBandStats( self, samplestep, argout+0, argout+1,
3362 : NULL, NULL );
3363 0 : }
3364 0 : SWIGINTERN CPLErr GDALRasterBandShadow_Fill__SWIG_0(GDALRasterBandShadow *self,double real_fill,double imag_fill=0.0){
3365 0 : return GDALFillRaster( self, real_fill, imag_fill );
3366 : }
3367 0 : SWIGINTERN void GDALRasterBandShadow_FlushCache(GDALRasterBandShadow *self){
3368 0 : GDALFlushRasterCache( self );
3369 0 : }
3370 0 : SWIGINTERN GDALColorTableShadow *GDALRasterBandShadow_GetRasterColorTable(GDALRasterBandShadow *self){
3371 0 : return (GDALColorTableShadow*) GDALGetRasterColorTable( self );
3372 : }
3373 0 : SWIGINTERN GDALColorTableShadow *GDALRasterBandShadow_GetColorTable(GDALRasterBandShadow *self){
3374 0 : return (GDALColorTableShadow*) GDALGetRasterColorTable( self );
3375 : }
3376 0 : SWIGINTERN int GDALRasterBandShadow_SetRasterColorTable(GDALRasterBandShadow *self,GDALColorTableShadow *arg){
3377 0 : return GDALSetRasterColorTable( self, arg );
3378 : }
3379 0 : SWIGINTERN int GDALRasterBandShadow_SetColorTable(GDALRasterBandShadow *self,GDALColorTableShadow *arg){
3380 0 : return GDALSetRasterColorTable( self, arg );
3381 : }
3382 1 : SWIGINTERN GDALRasterAttributeTableShadow *GDALRasterBandShadow_GetDefaultRAT(GDALRasterBandShadow *self){
3383 1 : return (GDALRasterAttributeTableShadow*) GDALGetDefaultRAT(self);
3384 : }
3385 0 : SWIGINTERN int GDALRasterBandShadow_SetDefaultRAT(GDALRasterBandShadow *self,GDALRasterAttributeTableShadow *table){
3386 0 : return GDALSetDefaultRAT(self, table);
3387 : }
3388 0 : SWIGINTERN GDALRasterBandShadow *GDALRasterBandShadow_GetMaskBand(GDALRasterBandShadow *self){
3389 0 : return (GDALRasterBandShadow *) GDALGetMaskBand( self );
3390 : }
3391 1 : SWIGINTERN int GDALRasterBandShadow_GetMaskFlags(GDALRasterBandShadow *self){
3392 1 : return GDALGetMaskFlags( self );
3393 : }
3394 0 : SWIGINTERN CPLErr GDALRasterBandShadow_CreateMaskBand(GDALRasterBandShadow *self,int nFlags){
3395 0 : return GDALCreateMaskBand( self, nFlags );
3396 : }
3397 0 : SWIGINTERN bool GDALRasterBandShadow_IsMaskBand(GDALRasterBandShadow *self){
3398 0 : return GDALIsMaskBand( self );
3399 : }
3400 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetDefaultHistogram(GDALRasterBandShadow *self,double min,double max,int buckets_in,int *panHistogram_in){
3401 0 : return GDALSetDefaultHistogram( self, min, max,
3402 0 : buckets_in, panHistogram_in );
3403 : }
3404 1 : SWIGINTERN bool GDALRasterBandShadow_HasArbitraryOverviews(GDALRasterBandShadow *self){
3405 1 : return (GDALHasArbitraryOverviews( self ) != 0) ? true : false;
3406 : }
3407 0 : SWIGINTERN char **GDALRasterBandShadow_GetCategoryNames(GDALRasterBandShadow *self){
3408 0 : return GDALGetRasterCategoryNames( self );
3409 : }
3410 0 : SWIGINTERN CPLErr GDALRasterBandShadow_SetCategoryNames(GDALRasterBandShadow *self,char **papszCategoryNames){
3411 0 : return GDALSetRasterCategoryNames( self, papszCategoryNames );
3412 : }
3413 0 : SWIGINTERN CPLErr GDALRasterBandShadow_AdviseRead__SWIG_0(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){
3414 0 : int nxsize = (buf_xsize==0) ? xsize : *buf_xsize;
3415 0 : int nysize = (buf_ysize==0) ? ysize : *buf_ysize;
3416 : GDALDataType ntype;
3417 0 : if ( buf_type != 0 ) {
3418 0 : ntype = (GDALDataType) *buf_type;
3419 : } else {
3420 0 : ntype = GDALGetRasterDataType( self );
3421 : }
3422 0 : return GDALRasterAdviseRead(self, xoff, yoff, xsize, ysize,
3423 0 : nxsize, nysize, ntype, options);
3424 : }
3425 0 : SWIGINTERN GDALMDArrayHS *GDALRasterBandShadow_AsMDArray(GDALRasterBandShadow *self){
3426 0 : return GDALRasterBandAsMDArray(self);
3427 : }
3428 0 : SWIGINTERN void GDALRasterBandShadow__EnablePixelTypeSignedByteWarning(GDALRasterBandShadow *self,bool b){
3429 0 : GDALEnablePixelTypeSignedByteWarning(self, b);
3430 0 : }
3431 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster_Direct__SWIG_0(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,void *nioBuffer,size_t nioBufferSize,int nPixelSpace=0,int nLineSpace=0){
3432 0 : return BandRasterIO( self, GF_Read,
3433 : xoff, yoff, xsize, ysize,
3434 : buf_xsize, buf_ysize,
3435 : buf_type,
3436 : nioBuffer, nioBufferSize,
3437 : nPixelSpace, nLineSpace,
3438 0 : GDT_Unknown, 0 );
3439 : }
3440 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_0(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,char *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3441 0 : return BandRasterIO( self, GF_Read,
3442 : xoff, yoff, xsize, ysize,
3443 : buf_xsize, buf_ysize,
3444 : buf_type,
3445 : regularArrayOut, nRegularArraySizeOut,
3446 : nPixelSpace, nLineSpace,
3447 0 : GDT_Byte, sizeof(char) );
3448 : }
3449 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_3(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,short *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3450 0 : return BandRasterIO( self, GF_Read,
3451 : xoff, yoff, xsize, ysize,
3452 : buf_xsize, buf_ysize,
3453 : buf_type,
3454 : regularArrayOut, nRegularArraySizeOut,
3455 : nPixelSpace, nLineSpace,
3456 0 : GDT_Int16, sizeof(short) );
3457 : }
3458 39999 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_6(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3459 39999 : return BandRasterIO( self, GF_Read,
3460 : xoff, yoff, xsize, ysize,
3461 : buf_xsize, buf_ysize,
3462 : buf_type,
3463 : regularArrayOut, nRegularArraySizeOut,
3464 : nPixelSpace, nLineSpace,
3465 39998 : GDT_Int32, sizeof(int) );
3466 : }
3467 1 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_9(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int64_t *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3468 1 : return BandRasterIO( self, GF_Read,
3469 : xoff, yoff, xsize, ysize,
3470 : buf_xsize, buf_ysize,
3471 : buf_type,
3472 : regularArrayOut, nRegularArraySizeOut,
3473 : nPixelSpace, nLineSpace,
3474 1 : GDT_Int64, sizeof(int64_t) );
3475 : }
3476 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_12(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,float *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3477 0 : return BandRasterIO( self, GF_Read,
3478 : xoff, yoff, xsize, ysize,
3479 : buf_xsize, buf_ysize,
3480 : buf_type,
3481 : regularArrayOut, nRegularArraySizeOut,
3482 : nPixelSpace, nLineSpace,
3483 0 : GDT_Float32, sizeof(float) );
3484 : }
3485 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadRaster__SWIG_15(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,double *regularArrayOut,size_t nRegularArraySizeOut,int nPixelSpace=0,int nLineSpace=0){
3486 0 : return BandRasterIO( self, GF_Read,
3487 : xoff, yoff, xsize, ysize,
3488 : buf_xsize, buf_ysize,
3489 : buf_type,
3490 : regularArrayOut, nRegularArraySizeOut,
3491 : nPixelSpace, nLineSpace,
3492 0 : GDT_Float64, sizeof(double) );
3493 : }
3494 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster_Direct__SWIG_0(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,void *nioBuffer,size_t nioBufferSize,int nPixelSpace=0,int nLineSpace=0){
3495 0 : return BandRasterIO( self, GF_Write,
3496 : xoff, yoff, xsize, ysize,
3497 : buf_xsize, buf_ysize,
3498 : buf_type,
3499 : nioBuffer, nioBufferSize,
3500 : nPixelSpace, nLineSpace,
3501 0 : GDT_Unknown, 0 );
3502 : }
3503 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_0(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,char *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3504 0 : return BandRasterIO( self, GF_Write,
3505 : xoff, yoff, xsize, ysize,
3506 : buf_xsize, buf_ysize,
3507 : buf_type,
3508 : regularArrayIn, nRegularArraySizeIn,
3509 : nPixelSpace, nLineSpace,
3510 0 : GDT_Byte, sizeof(char) );
3511 : }
3512 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_3(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,short *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3513 0 : return BandRasterIO( self, GF_Write,
3514 : xoff, yoff, xsize, ysize,
3515 : buf_xsize, buf_ysize,
3516 : buf_type,
3517 : regularArrayIn, nRegularArraySizeIn,
3518 : nPixelSpace, nLineSpace,
3519 0 : GDT_Int16, sizeof(short) );
3520 : }
3521 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_6(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3522 0 : return BandRasterIO( self, GF_Write,
3523 : xoff, yoff, xsize, ysize,
3524 : buf_xsize, buf_ysize,
3525 : buf_type,
3526 : regularArrayIn, nRegularArraySizeIn,
3527 : nPixelSpace, nLineSpace,
3528 0 : GDT_Int32, sizeof(int) );
3529 : }
3530 1 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_9(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,int64_t *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3531 1 : return BandRasterIO( self, GF_Write,
3532 : xoff, yoff, xsize, ysize,
3533 : buf_xsize, buf_ysize,
3534 : buf_type,
3535 : regularArrayIn, nRegularArraySizeIn,
3536 : nPixelSpace, nLineSpace,
3537 1 : GDT_Int64, sizeof(int64_t) );
3538 : }
3539 39992 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_12(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,float *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3540 39992 : return BandRasterIO( self, GF_Write,
3541 : xoff, yoff, xsize, ysize,
3542 : buf_xsize, buf_ysize,
3543 : buf_type,
3544 : regularArrayIn, nRegularArraySizeIn,
3545 : nPixelSpace, nLineSpace,
3546 39984 : GDT_Float32, sizeof(float) );
3547 : }
3548 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteRaster__SWIG_15(GDALRasterBandShadow *self,int xoff,int yoff,int xsize,int ysize,int buf_xsize,int buf_ysize,GDALDataType buf_type,double *regularArrayIn,size_t nRegularArraySizeIn,int nPixelSpace=0,int nLineSpace=0){
3549 0 : return BandRasterIO( self, GF_Write,
3550 : xoff, yoff, xsize, ysize,
3551 : buf_xsize, buf_ysize,
3552 : buf_type,
3553 : regularArrayIn, nRegularArraySizeIn,
3554 : nPixelSpace, nLineSpace,
3555 0 : GDT_Float64, sizeof(double) );
3556 : }
3557 0 : SWIGINTERN CPLErr GDALRasterBandShadow_ReadBlock_Direct(GDALRasterBandShadow *self,int nXBlockOff,int nYBlockOff,void *nioBuffer,size_t nioBufferSize){
3558 0 : if (BandBlockReadWrite_Validate((GDALRasterBandH)self, nioBuffer, nioBufferSize) != CE_None)
3559 0 : return CE_Failure;
3560 :
3561 0 : return GDALReadBlock(self, nXBlockOff, nYBlockOff, nioBuffer);
3562 : }
3563 0 : SWIGINTERN CPLErr GDALRasterBandShadow_WriteBlock_Direct(GDALRasterBandShadow *self,int nXBlockOff,int nYBlockOff,void *nioBuffer,size_t nioBufferSize){
3564 0 : if (BandBlockReadWrite_Validate((GDALRasterBandH)self, nioBuffer, nioBufferSize) != CE_None)
3565 0 : return CE_Failure;
3566 :
3567 0 : return GDALWriteBlock(self, nXBlockOff, nYBlockOff, nioBuffer);
3568 : }
3569 0 : SWIGINTERN CPLErr GDALRasterBandShadow_GetHistogram__SWIG_0(GDALRasterBandShadow *self,double min,double max,int buckets,int *panHistogram,bool include_out_of_range,bool approx_ok,GDALProgressFunc callback,void *callback_data){
3570 0 : CPLErrorReset();
3571 0 : CPLErr err = GDALGetRasterHistogram( self, min, max, buckets, panHistogram,
3572 : include_out_of_range, approx_ok,
3573 : callback, callback_data );
3574 0 : return err;
3575 : }
3576 0 : SWIGINTERN CPLErr GDALRasterBandShadow_GetHistogram__SWIG_1(GDALRasterBandShadow *self,double min,double max,int buckets,int *panHistogram,bool include_out_of_range,bool approx_ok){
3577 0 : CPLErrorReset();
3578 0 : CPLErr err = GDALGetRasterHistogram( self, min, max, buckets, panHistogram,
3579 : include_out_of_range, approx_ok,
3580 : NULL, NULL);
3581 0 : return err;
3582 : }
3583 0 : SWIGINTERN CPLErr GDALRasterBandShadow_GetHistogram__SWIG_2(GDALRasterBandShadow *self,double min,double max,int buckets,int *panHistogram){
3584 0 : CPLErrorReset();
3585 0 : CPLErr err = GDALGetRasterHistogram( self, min, max, buckets, panHistogram,
3586 : 0, 1,
3587 : NULL, NULL);
3588 0 : return err;
3589 : }
3590 0 : SWIGINTERN CPLErr GDALRasterBandShadow_GetHistogram__SWIG_3(GDALRasterBandShadow *self,int buckets,int *panHistogram){
3591 0 : CPLErrorReset();
3592 0 : CPLErr err = GDALGetRasterHistogram( self, -0.5, 255.5, buckets, panHistogram,
3593 : 0, 1,
3594 : NULL, NULL);
3595 0 : return err;
3596 : }
3597 0 : SWIGINTERN CPLErr GDALRasterBandShadow_GetDefaultHistogram__SWIG_0(GDALRasterBandShadow *self,double *min_ret,double *max_ret,int *buckets_ret,int **ppanHistogram,bool force=1,GDALProgressFunc callback=NULL,void *callback_data=NULL){
3598 0 : return GDALGetDefaultHistogram( self, min_ret, max_ret, buckets_ret,
3599 : ppanHistogram, force,
3600 0 : callback, callback_data );
3601 : }
3602 :
3603 4 : GDALDataType GDALRasterBandShadow_DataType_get( GDALRasterBandShadow *h ) {
3604 4 : return GDALGetRasterDataType( h );
3605 : }
3606 8 : int GDALRasterBandShadow_XSize_get( GDALRasterBandShadow *h ) {
3607 8 : return GDALGetRasterBandXSize( h );
3608 : }
3609 8 : int GDALRasterBandShadow_YSize_get( GDALRasterBandShadow *h ) {
3610 8 : return GDALGetRasterBandYSize( h );
3611 : }
3612 :
3613 0 : SWIGINTERN GDALColorTableShadow *new_GDALColorTableShadow__SWIG_0(GDALPaletteInterp palette=GPI_RGB){
3614 0 : return (GDALColorTableShadow*) GDALCreateColorTable(palette);
3615 : }
3616 0 : SWIGINTERN void delete_GDALColorTableShadow(GDALColorTableShadow *self){
3617 0 : GDALDestroyColorTable(self);
3618 0 : }
3619 0 : SWIGINTERN GDALColorTableShadow *GDALColorTableShadow_Clone(GDALColorTableShadow *self){
3620 0 : return (GDALColorTableShadow*) GDALCloneColorTable (self);
3621 : }
3622 0 : SWIGINTERN GDALPaletteInterp GDALColorTableShadow_GetPaletteInterpretation(GDALColorTableShadow *self){
3623 0 : return GDALGetPaletteInterpretation(self);
3624 : }
3625 0 : SWIGINTERN int GDALColorTableShadow_GetColorEntryCount(GDALColorTableShadow *self){
3626 0 : return GDALGetColorEntryCount(self);
3627 : }
3628 0 : SWIGINTERN GDALColorEntry *GDALColorTableShadow_GetColorEntry(GDALColorTableShadow *self,int entry){
3629 0 : return (GDALColorEntry*) GDALGetColorEntry(self, entry);
3630 : }
3631 0 : SWIGINTERN void GDALColorTableShadow_SetColorEntry(GDALColorTableShadow *self,int entry,GDALColorEntry const *centry){
3632 0 : GDALSetColorEntry(self, entry, centry);
3633 0 : }
3634 0 : SWIGINTERN void GDALColorTableShadow_CreateColorRamp(GDALColorTableShadow *self,int nStartIndex,GDALColorEntry const *startcolor,int nEndIndex,GDALColorEntry const *endcolor){
3635 0 : GDALCreateColorRamp(self, nStartIndex, startcolor, nEndIndex, endcolor);
3636 0 : }
3637 :
3638 : #include "gdalsubdatasetinfo.h"
3639 :
3640 0 : SWIGINTERN void delete_GDALSubdatasetInfoShadow(GDALSubdatasetInfoShadow *self){
3641 0 : GDALDestroySubdatasetInfo(reinterpret_cast<GDALSubdatasetInfoH>(self));
3642 0 : }
3643 0 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_GetPathComponent(GDALSubdatasetInfoShadow *self){
3644 0 : return GDALSubdatasetInfoGetPathComponent(reinterpret_cast<GDALSubdatasetInfoH>(self) );
3645 : }
3646 0 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_GetSubdatasetComponent(GDALSubdatasetInfoShadow *self){
3647 0 : return GDALSubdatasetInfoGetSubdatasetComponent(reinterpret_cast<GDALSubdatasetInfoH>(self) );
3648 : }
3649 0 : SWIGINTERN retStringAndCPLFree *GDALSubdatasetInfoShadow_ModifyPathComponent(GDALSubdatasetInfoShadow *self,char const *pszNewFileName){
3650 0 : return GDALSubdatasetInfoModifyPathComponent(reinterpret_cast<GDALSubdatasetInfoH>(self), pszNewFileName );
3651 : }
3652 :
3653 0 : GDALSubdatasetInfoShadow* GetSubdatasetInfo(const char *pszFileName)
3654 : {
3655 0 : GDALSubdatasetInfoH info { GDALGetSubdatasetInfo(pszFileName) };
3656 :
3657 0 : if( ! info )
3658 : {
3659 0 : return nullptr;
3660 : }
3661 :
3662 0 : return (GDALSubdatasetInfoShadow*)( info );
3663 : };
3664 :
3665 0 : SWIGINTERN GDALRelationshipShadow *new_GDALRelationshipShadow(char const *name,char const *leftTableName,char const *rightTableName,GDALRelationshipCardinality cardinality){
3666 : return (GDALRelationshipShadow*)
3667 0 : GDALRelationshipCreate(name,
3668 : leftTableName,
3669 : rightTableName,
3670 0 : cardinality);
3671 : }
3672 0 : SWIGINTERN void delete_GDALRelationshipShadow(GDALRelationshipShadow *self){
3673 0 : GDALDestroyRelationship(self);
3674 0 : }
3675 0 : SWIGINTERN char const *GDALRelationshipShadow_GetName(GDALRelationshipShadow *self){
3676 0 : return GDALRelationshipGetName( self );
3677 : }
3678 0 : SWIGINTERN GDALRelationshipCardinality GDALRelationshipShadow_GetCardinality(GDALRelationshipShadow *self){
3679 0 : return GDALRelationshipGetCardinality( self );
3680 : }
3681 0 : SWIGINTERN char const *GDALRelationshipShadow_GetLeftTableName(GDALRelationshipShadow *self){
3682 0 : return GDALRelationshipGetLeftTableName( self );
3683 : }
3684 0 : SWIGINTERN char const *GDALRelationshipShadow_GetRightTableName(GDALRelationshipShadow *self){
3685 0 : return GDALRelationshipGetRightTableName( self );
3686 : }
3687 0 : SWIGINTERN char const *GDALRelationshipShadow_GetMappingTableName(GDALRelationshipShadow *self){
3688 0 : return GDALRelationshipGetMappingTableName( self );
3689 : }
3690 0 : SWIGINTERN void GDALRelationshipShadow_SetMappingTableName(GDALRelationshipShadow *self,char const *pszName){
3691 0 : GDALRelationshipSetMappingTableName( self, pszName );
3692 0 : }
3693 0 : SWIGINTERN char **GDALRelationshipShadow_GetLeftTableFields(GDALRelationshipShadow *self){
3694 0 : return GDALRelationshipGetLeftTableFields(self);
3695 : }
3696 0 : SWIGINTERN char **GDALRelationshipShadow_GetRightTableFields(GDALRelationshipShadow *self){
3697 0 : return GDALRelationshipGetRightTableFields(self);
3698 : }
3699 0 : SWIGINTERN void GDALRelationshipShadow_SetLeftTableFields(GDALRelationshipShadow *self,char **pFields){
3700 0 : GDALRelationshipSetLeftTableFields(self, pFields);
3701 0 : }
3702 0 : SWIGINTERN void GDALRelationshipShadow_SetRightTableFields(GDALRelationshipShadow *self,char **pFields){
3703 0 : GDALRelationshipSetRightTableFields(self, pFields);
3704 0 : }
3705 0 : SWIGINTERN char **GDALRelationshipShadow_GetLeftMappingTableFields(GDALRelationshipShadow *self){
3706 0 : return GDALRelationshipGetLeftMappingTableFields(self);
3707 : }
3708 0 : SWIGINTERN char **GDALRelationshipShadow_GetRightMappingTableFields(GDALRelationshipShadow *self){
3709 0 : return GDALRelationshipGetRightMappingTableFields(self);
3710 : }
3711 0 : SWIGINTERN void GDALRelationshipShadow_SetLeftMappingTableFields(GDALRelationshipShadow *self,char **pFields){
3712 0 : GDALRelationshipSetLeftMappingTableFields(self, pFields);
3713 0 : }
3714 0 : SWIGINTERN void GDALRelationshipShadow_SetRightMappingTableFields(GDALRelationshipShadow *self,char **pFields){
3715 0 : GDALRelationshipSetRightMappingTableFields(self, pFields);
3716 0 : }
3717 0 : SWIGINTERN GDALRelationshipType GDALRelationshipShadow_GetType(GDALRelationshipShadow *self){
3718 0 : return GDALRelationshipGetType( self );
3719 : }
3720 0 : SWIGINTERN void GDALRelationshipShadow_SetType(GDALRelationshipShadow *self,GDALRelationshipType type){
3721 0 : return GDALRelationshipSetType( self, type );
3722 : }
3723 0 : SWIGINTERN char const *GDALRelationshipShadow_GetForwardPathLabel(GDALRelationshipShadow *self){
3724 0 : return GDALRelationshipGetForwardPathLabel( self );
3725 : }
3726 0 : SWIGINTERN void GDALRelationshipShadow_SetForwardPathLabel(GDALRelationshipShadow *self,char const *pszLabel){
3727 0 : GDALRelationshipSetForwardPathLabel( self, pszLabel );
3728 0 : }
3729 0 : SWIGINTERN char const *GDALRelationshipShadow_GetBackwardPathLabel(GDALRelationshipShadow *self){
3730 0 : return GDALRelationshipGetBackwardPathLabel( self );
3731 : }
3732 0 : SWIGINTERN void GDALRelationshipShadow_SetBackwardPathLabel(GDALRelationshipShadow *self,char const *pszLabel){
3733 0 : GDALRelationshipSetBackwardPathLabel( self, pszLabel );
3734 0 : }
3735 0 : SWIGINTERN char const *GDALRelationshipShadow_GetRelatedTableType(GDALRelationshipShadow *self){
3736 0 : return GDALRelationshipGetRelatedTableType( self );
3737 : }
3738 0 : SWIGINTERN void GDALRelationshipShadow_SetRelatedTableType(GDALRelationshipShadow *self,char const *pszType){
3739 0 : GDALRelationshipSetRelatedTableType( self, pszType );
3740 0 : }
3741 :
3742 : #include "gdalgrid.h"
3743 :
3744 : #ifdef DEBUG
3745 : typedef struct OGRLayerHS OGRLayerShadow;
3746 : typedef struct OGRGeometryHS OGRGeometryShadow;
3747 : #else
3748 : typedef void OGRLayerShadow;
3749 : typedef void OGRGeometryShadow;
3750 : #endif
3751 :
3752 :
3753 0 : int ComputeMedianCutPCT ( GDALRasterBandShadow *red,
3754 : GDALRasterBandShadow *green,
3755 : GDALRasterBandShadow *blue,
3756 : int num_colors,
3757 : GDALColorTableShadow* colors,
3758 : GDALProgressFunc callback = NULL,
3759 : void* callback_data=NULL) {
3760 :
3761 0 : CPLErrorReset();
3762 :
3763 0 : int err = GDALComputeMedianCutPCT( red,
3764 : green,
3765 : blue,
3766 : NULL,
3767 : num_colors,
3768 : colors,
3769 : callback,
3770 : callback_data);
3771 :
3772 0 : return err;
3773 : }
3774 :
3775 :
3776 0 : int DitherRGB2PCT ( GDALRasterBandShadow *red,
3777 : GDALRasterBandShadow *green,
3778 : GDALRasterBandShadow *blue,
3779 : GDALRasterBandShadow *target,
3780 : GDALColorTableShadow *colors,
3781 : GDALProgressFunc callback = NULL,
3782 : void* callback_data=NULL) {
3783 :
3784 0 : CPLErrorReset();
3785 : int err;
3786 0 : err = GDALDitherRGB2PCT( red,
3787 : green,
3788 : blue,
3789 : target,
3790 : colors,
3791 : callback,
3792 : callback_data);
3793 :
3794 0 : return err;
3795 : }
3796 :
3797 :
3798 0 : CPLErr ReprojectImage ( GDALDatasetShadow *src_ds,
3799 : GDALDatasetShadow *dst_ds,
3800 : const char *src_wkt=NULL,
3801 : const char *dst_wkt=NULL,
3802 : GDALResampleAlg eResampleAlg=GRA_NearestNeighbour,
3803 : double WarpMemoryLimit=0.0,
3804 : double maxerror = 0.0,
3805 : GDALProgressFunc callback = NULL,
3806 : void* callback_data=NULL,
3807 : char** options = NULL ) {
3808 :
3809 0 : CPLErrorReset();
3810 :
3811 0 : GDALWarpOptions* psOptions = NULL;
3812 0 : if( options != NULL )
3813 : {
3814 0 : psOptions = GDALCreateWarpOptions();
3815 0 : psOptions->papszWarpOptions = CSLDuplicate(options);
3816 : }
3817 :
3818 0 : CPLErr err = GDALReprojectImage( src_ds,
3819 : src_wkt,
3820 : dst_ds,
3821 : dst_wkt,
3822 : eResampleAlg,
3823 : WarpMemoryLimit,
3824 : maxerror,
3825 : callback,
3826 : callback_data,
3827 : psOptions);
3828 :
3829 0 : if( psOptions != NULL )
3830 0 : GDALDestroyWarpOptions(psOptions);
3831 :
3832 0 : return err;
3833 : }
3834 :
3835 :
3836 0 : int ComputeProximity( GDALRasterBandShadow *srcBand,
3837 : GDALRasterBandShadow *proximityBand,
3838 : char **options = NULL,
3839 : GDALProgressFunc callback=NULL,
3840 : void* callback_data=NULL) {
3841 :
3842 0 : CPLErrorReset();
3843 :
3844 0 : return GDALComputeProximity( srcBand, proximityBand, options,
3845 0 : callback, callback_data );
3846 : }
3847 :
3848 :
3849 0 : int RasterizeLayer( GDALDatasetShadow *dataset,
3850 : int bands, int *band_list,
3851 : OGRLayerShadow *layer,
3852 : int burn_values = 0, double *burn_values_list = NULL,
3853 : char **options = NULL,
3854 : GDALProgressFunc callback=NULL,
3855 : void* callback_data=NULL) {
3856 :
3857 : CPLErr eErr;
3858 :
3859 0 : CPLErrorReset();
3860 :
3861 0 : if( burn_values == 0 )
3862 : {
3863 0 : burn_values_list = (double *) CPLMalloc(sizeof(double)*bands);
3864 0 : for( int i = 0; i < bands; i++ )
3865 0 : burn_values_list[i] = 255.0;
3866 : }
3867 0 : else if( burn_values != bands )
3868 : {
3869 0 : CPLError( CE_Failure, CPLE_AppDefined,
3870 : "Did not get the expected number of burn values in RasterizeLayer()" );
3871 0 : return CE_Failure;
3872 : }
3873 :
3874 0 : eErr = GDALRasterizeLayers( dataset, bands, band_list,
3875 : 1, &layer,
3876 : NULL, NULL,
3877 : burn_values_list, options,
3878 : callback, callback_data );
3879 :
3880 0 : if( burn_values == 0 )
3881 0 : CPLFree( burn_values_list );
3882 :
3883 0 : return eErr;
3884 : }
3885 :
3886 :
3887 0 : int Polygonize( GDALRasterBandShadow *srcBand,
3888 : GDALRasterBandShadow *maskBand,
3889 : OGRLayerShadow *outLayer,
3890 : int iPixValField,
3891 : char **options = NULL,
3892 : GDALProgressFunc callback=NULL,
3893 : void* callback_data=NULL) {
3894 :
3895 0 : CPLErrorReset();
3896 :
3897 0 : return GDALPolygonize( srcBand, maskBand, outLayer, iPixValField,
3898 0 : options, callback, callback_data );
3899 : }
3900 :
3901 :
3902 0 : int FPolygonize( GDALRasterBandShadow *srcBand,
3903 : GDALRasterBandShadow *maskBand,
3904 : OGRLayerShadow *outLayer,
3905 : int iPixValField,
3906 : char **options = NULL,
3907 : GDALProgressFunc callback=NULL,
3908 : void* callback_data=NULL) {
3909 :
3910 0 : CPLErrorReset();
3911 :
3912 0 : return GDALFPolygonize( srcBand, maskBand, outLayer, iPixValField,
3913 0 : options, callback, callback_data );
3914 : }
3915 :
3916 :
3917 0 : int FillNodata( GDALRasterBandShadow *targetBand,
3918 : GDALRasterBandShadow *maskBand,
3919 : double maxSearchDist,
3920 : int smoothingIterations,
3921 : char **options = NULL,
3922 : GDALProgressFunc callback=NULL,
3923 : void* callback_data=NULL) {
3924 :
3925 0 : CPLErrorReset();
3926 :
3927 0 : return GDALFillNodata( targetBand, maskBand, maxSearchDist,
3928 : 0, smoothingIterations, options,
3929 0 : callback, callback_data );
3930 : }
3931 :
3932 :
3933 0 : int SieveFilter( GDALRasterBandShadow *srcBand,
3934 : GDALRasterBandShadow *maskBand,
3935 : GDALRasterBandShadow *dstBand,
3936 : int threshold, int connectedness=4,
3937 : char **options = NULL,
3938 : GDALProgressFunc callback=NULL,
3939 : void* callback_data=NULL) {
3940 :
3941 0 : CPLErrorReset();
3942 :
3943 0 : return GDALSieveFilter( srcBand, maskBand, dstBand,
3944 : threshold, connectedness,
3945 0 : options, callback, callback_data );
3946 : }
3947 :
3948 :
3949 0 : int RegenerateOverviews( GDALRasterBandShadow *srcBand,
3950 : int overviewBandCount,
3951 : GDALRasterBandShadow **overviewBands,
3952 : const char *resampling = "average",
3953 : GDALProgressFunc callback=NULL,
3954 : void* callback_data=NULL) {
3955 :
3956 0 : CPLErrorReset();
3957 :
3958 0 : return GDALRegenerateOverviews( srcBand, overviewBandCount, overviewBands,
3959 0 : resampling ? resampling : "average", callback, callback_data );
3960 : }
3961 :
3962 :
3963 0 : int RegenerateOverview( GDALRasterBandShadow *srcBand,
3964 : GDALRasterBandShadow *overviewBand,
3965 : const char *resampling = "average",
3966 : GDALProgressFunc callback=NULL,
3967 : void* callback_data=NULL) {
3968 :
3969 0 : CPLErrorReset();
3970 :
3971 0 : return GDALRegenerateOverviews( srcBand, 1, &overviewBand,
3972 0 : resampling ? resampling : "average", callback, callback_data );
3973 : }
3974 :
3975 :
3976 0 : int wrapper_GridCreate( char* algorithmOptions,
3977 : int points, double *x, double *y, double *z,
3978 : double xMin, double xMax, double yMin, double yMax,
3979 : int xSize, int ySize, GDALDataType dataType,
3980 : void* nioBuffer, size_t nioBufferSize,
3981 : GDALProgressFunc callback = NULL,
3982 : void* callback_data = NULL)
3983 : {
3984 0 : GDALGridAlgorithm eAlgorithm = GGA_InverseDistanceToAPower;
3985 0 : void* pOptions = NULL;
3986 :
3987 0 : CPLErr eErr = CE_Failure;
3988 :
3989 0 : CPLErrorReset();
3990 :
3991 0 : if ((GUIntBig)xSize * ySize * GDALGetDataTypeSizeBytes(dataType) > nioBufferSize)
3992 : {
3993 0 : CPLError( eErr, CPLE_AppDefined, "Buffer too small" );
3994 0 : return eErr;
3995 : }
3996 :
3997 0 : if ( algorithmOptions )
3998 : {
3999 0 : eErr = GDALGridParseAlgorithmAndOptions( algorithmOptions, &eAlgorithm, &pOptions );
4000 : }
4001 : else
4002 : {
4003 0 : eErr = GDALGridParseAlgorithmAndOptions( szAlgNameInvDist, &eAlgorithm, &pOptions );
4004 : }
4005 :
4006 0 : if ( eErr != CE_None )
4007 : {
4008 0 : CPLError( eErr, CPLE_AppDefined, "Failed to process algorithm name and parameters.\n" );
4009 0 : return eErr;
4010 : }
4011 :
4012 0 : eErr = GDALGridCreate( eAlgorithm, pOptions, points, x, y, z,
4013 : xMin, xMax, yMin, yMax, xSize, ySize, dataType, nioBuffer,
4014 : callback, callback_data );
4015 :
4016 0 : CPLFree(pOptions);
4017 :
4018 0 : return eErr;
4019 : }
4020 :
4021 :
4022 1 : int ContourGenerate( GDALRasterBandShadow *srcBand,
4023 : double contourInterval,
4024 : double contourBase,
4025 : int fixedLevelCount,
4026 : double *fixedLevels,
4027 : int useNoData,
4028 : double noDataValue,
4029 : OGRLayerShadow* dstLayer,
4030 : int idField,
4031 : int elevField,
4032 : GDALProgressFunc callback = NULL,
4033 : void* callback_data = NULL)
4034 : {
4035 : CPLErr eErr;
4036 :
4037 1 : CPLErrorReset();
4038 :
4039 1 : eErr = GDALContourGenerate( srcBand,
4040 : contourInterval,
4041 : contourBase,
4042 : fixedLevelCount,
4043 : fixedLevels,
4044 : useNoData,
4045 : noDataValue,
4046 : dstLayer,
4047 : idField,
4048 : elevField,
4049 : callback,
4050 : callback_data);
4051 :
4052 1 : return eErr;
4053 : }
4054 :
4055 :
4056 0 : int ContourGenerateEx( GDALRasterBandShadow *srcBand,
4057 : OGRLayerShadow* dstLayer,
4058 : char** options = NULL,
4059 : GDALProgressFunc callback = NULL,
4060 : void* callback_data = NULL )
4061 : {
4062 : CPLErr eErr;
4063 :
4064 0 : CPLErrorReset();
4065 :
4066 0 : eErr = GDALContourGenerateEx( srcBand,
4067 : dstLayer,
4068 : options,
4069 : callback,
4070 : callback_data);
4071 :
4072 0 : return eErr;
4073 : }
4074 :
4075 :
4076 0 : GDALDatasetShadow *ViewshedGenerate( GDALRasterBandShadow *srcBand,
4077 : const char* driverName,
4078 : const char* targetRasterName,
4079 : char** creationOptions,
4080 : double observerX, double observerY, double observerHeight,
4081 : double targetHeight, double visibleVal, double invisibleVal,
4082 : double outOfRangeVal, double noDataVal, double dfCurvCoeff,
4083 : GDALViewshedMode mode, double maxDistance,
4084 : GDALProgressFunc callback = NULL, void* callback_data = NULL,
4085 : GDALViewshedOutputType heightMode = GVOT_NORMAL,
4086 : char** options = NULL)
4087 : {
4088 0 : GDALDatasetShadow* ds = GDALViewshedGenerate( srcBand,
4089 : driverName,
4090 : targetRasterName,
4091 : creationOptions,
4092 : observerX,
4093 : observerY,
4094 : observerHeight,
4095 : targetHeight,
4096 : visibleVal,
4097 : invisibleVal,
4098 : outOfRangeVal,
4099 : noDataVal,
4100 : dfCurvCoeff,
4101 : mode,
4102 : maxDistance,
4103 : callback,
4104 : callback_data,
4105 : heightMode,
4106 : options);
4107 : if (ds == 0) {
4108 : /*throw CPLGetLastErrorMsg(); causes a SWIG_exception later*/
4109 : }
4110 0 : return ds;
4111 : }
4112 :
4113 :
4114 0 : bool IsLineOfSightVisible(GDALRasterBandShadow *band,
4115 : int xA, int yA, double zA,
4116 : int xB, int yB, double zB,
4117 : char** options = NULL)
4118 : {
4119 0 : return GDALIsLineOfSightVisible(band, xA, yA, zA, xB, yB, zB, NULL, NULL, options);
4120 : }
4121 :
4122 :
4123 0 : GDALDatasetShadow *AutoCreateWarpedVRT( GDALDatasetShadow *src_ds,
4124 : const char *src_wkt = 0,
4125 : const char *dst_wkt = 0,
4126 : GDALResampleAlg eResampleAlg = GRA_NearestNeighbour,
4127 : double maxerror = 0.0 ) {
4128 0 : GDALDatasetShadow *ds = GDALAutoCreateWarpedVRT( src_ds, src_wkt,
4129 : dst_wkt,
4130 : eResampleAlg,
4131 : maxerror,
4132 : 0 );
4133 : if (ds == 0) {
4134 : /*throw CPLGetLastErrorMsg(); causes a SWIG_exception later*/
4135 : }
4136 0 : return ds;
4137 :
4138 : }
4139 :
4140 :
4141 0 : GDALDatasetShadow* CreatePansharpenedVRT( const char* pszXML,
4142 : GDALRasterBandShadow* panchroBand,
4143 : int nInputSpectralBands,
4144 : GDALRasterBandShadow** ahInputSpectralBands )
4145 : {
4146 0 : CPLErrorReset();
4147 :
4148 0 : return (GDALDatasetShadow*)GDALCreatePansharpenedVRT( pszXML, panchroBand,
4149 0 : nInputSpectralBands, ahInputSpectralBands );
4150 : }
4151 :
4152 0 : SWIGINTERN GDALTransformerInfoShadow *new_GDALTransformerInfoShadow(GDALDatasetShadow *src,GDALDatasetShadow *dst,char **options){
4153 : GDALTransformerInfoShadow *obj = (GDALTransformerInfoShadow*)
4154 0 : GDALCreateGenImgProjTransformer2( (GDALDatasetH)src, (GDALDatasetH)dst,
4155 : options );
4156 0 : return obj;
4157 : }
4158 0 : SWIGINTERN void delete_GDALTransformerInfoShadow(GDALTransformerInfoShadow *self){
4159 0 : GDALDestroyTransformer( self );
4160 0 : }
4161 0 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoint__SWIG_0(GDALTransformerInfoShadow *self,int bDstToSrc,double inout[3]){
4162 0 : int nRet, nSuccess = TRUE;
4163 :
4164 0 : nRet = GDALUseTransformer( self, bDstToSrc,
4165 : 1, &inout[0], &inout[1], &inout[2],
4166 : &nSuccess );
4167 :
4168 0 : return nRet && nSuccess;
4169 : }
4170 0 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoint__SWIG_1(GDALTransformerInfoShadow *self,double argout[3],int bDstToSrc,double x,double y,double z=0.0){
4171 0 : int nRet, nSuccess = TRUE;
4172 :
4173 0 : argout[0] = x;
4174 0 : argout[1] = y;
4175 0 : argout[2] = z;
4176 0 : nRet = GDALUseTransformer( self, bDstToSrc,
4177 : 1, &argout[0], &argout[1], &argout[2],
4178 : &nSuccess );
4179 :
4180 0 : return nRet && nSuccess;
4181 : }
4182 0 : SWIGINTERN int GDALTransformerInfoShadow_TransformPoints(GDALTransformerInfoShadow *self,int bDstToSrc,int nCount,double *x,double *y,double *z,int *panSuccess){
4183 : int nRet;
4184 :
4185 0 : nRet = GDALUseTransformer( self, bDstToSrc, nCount, x, y, z, panSuccess );
4186 :
4187 0 : return nRet;
4188 : }
4189 0 : SWIGINTERN int GDALTransformerInfoShadow_TransformGeolocations__SWIG_0(GDALTransformerInfoShadow *self,GDALRasterBandShadow *xBand,GDALRasterBandShadow *yBand,GDALRasterBandShadow *zBand,GDALProgressFunc callback=NULL,void *callback_data=NULL,char **options=NULL){
4190 :
4191 0 : CPLErrorReset();
4192 :
4193 0 : return GDALTransformGeolocations( xBand, yBand, zBand,
4194 : GDALUseTransformer, self,
4195 0 : callback, callback_data, options );
4196 : }
4197 :
4198 : typedef struct
4199 : {
4200 : int width;
4201 : int height;
4202 : double xmin;
4203 : double ymin;
4204 : double xmax;
4205 : double ymax;
4206 : double geotransform[6];
4207 : } SuggestedWarpOutputRes;
4208 :
4209 0 : SWIGINTERN void delete_SuggestedWarpOutputRes(SuggestedWarpOutputRes *self){
4210 0 : CPLFree(self);
4211 0 : }
4212 0 : SWIGINTERN void SuggestedWarpOutputRes_GetGeotransform(SuggestedWarpOutputRes *self,double geotransform[6]){
4213 0 : memcpy(geotransform, self->geotransform, 6 * sizeof(double));
4214 0 : }
4215 :
4216 : #ifdef SWIGPYTHON
4217 : SuggestedWarpOutputRes* SuggestedWarpOutputFromTransformer(
4218 : GDALDatasetShadow *src,
4219 : GDALTransformerInfoShadow* transformer )
4220 : #else
4221 0 : SuggestedWarpOutputRes* SuggestedWarpOutput( GDALDatasetShadow *src,
4222 : GDALTransformerInfoShadow* transformer )
4223 : #endif
4224 : {
4225 0 : SuggestedWarpOutputRes* res = (SuggestedWarpOutputRes*)CPLMalloc(sizeof(SuggestedWarpOutputRes));
4226 : double extent[4];
4227 0 : if( GDALSuggestedWarpOutput2(src, GDALGenImgProjTransform, transformer,
4228 0 : res->geotransform,&(res->width), &(res->height),
4229 0 : extent, 0) != CE_None )
4230 : {
4231 0 : CPLFree(res);
4232 0 : return NULL;
4233 : }
4234 0 : res->xmin = extent[0];
4235 0 : res->ymin = extent[1];
4236 0 : res->xmax = extent[2];
4237 0 : res->ymax = extent[3];
4238 0 : return res;
4239 : }
4240 :
4241 :
4242 : #ifdef SWIGPYTHON
4243 : SuggestedWarpOutputRes* SuggestedWarpOutputFromOptions( GDALDatasetShadow *src,
4244 : char** options )
4245 : #else
4246 0 : SuggestedWarpOutputRes* SuggestedWarpOutput( GDALDatasetShadow *src,
4247 : char** options )
4248 : #endif
4249 : {
4250 0 : SuggestedWarpOutputRes* res = (SuggestedWarpOutputRes*)CPLMalloc(sizeof(SuggestedWarpOutputRes));
4251 : double extent[4];
4252 0 : void* pTransformArg = GDALCreateGenImgProjTransformer2( src, NULL, options );
4253 0 : if( GDALSuggestedWarpOutput2(src, GDALGenImgProjTransform, pTransformArg,
4254 0 : res->geotransform,&(res->width), &(res->height),
4255 0 : extent, 0) != CE_None )
4256 : {
4257 0 : GDALDestroyTransformer(pTransformArg);
4258 0 : CPLFree(res);
4259 0 : return NULL;
4260 : }
4261 0 : GDALDestroyTransformer(pTransformArg);
4262 0 : res->xmin = extent[0];
4263 0 : res->ymin = extent[1];
4264 0 : res->xmax = extent[2];
4265 0 : res->ymax = extent[3];
4266 0 : return res;
4267 : }
4268 :
4269 :
4270 0 : GDALDatasetShadow* ApplyVerticalShiftGrid( GDALDatasetShadow *src_ds,
4271 : GDALDatasetShadow *grid_ds,
4272 : bool inverse = false,
4273 : double srcUnitToMeter = 1.0,
4274 : double dstUnitToMeter = 1.0,
4275 : char** options = NULL ) {
4276 0 : GDALDatasetShadow *ds = GDALApplyVerticalShiftGrid( src_ds, grid_ds,
4277 : inverse,
4278 : srcUnitToMeter,
4279 : dstUnitToMeter,
4280 : options );
4281 0 : return ds;
4282 :
4283 : }
4284 :
4285 :
4286 0 : const char *wrapper_GDALVersionInfo( const char *request = "VERSION_NUM" )
4287 : {
4288 0 : return GDALVersionInfo(request ? request : "VERSION_NUM");
4289 : }
4290 :
4291 :
4292 0 : int wrapper_GDALGetCacheMax()
4293 : {
4294 0 : return GDALGetCacheMax();
4295 : }
4296 :
4297 :
4298 0 : int wrapper_GDALGetCacheUsed()
4299 : {
4300 0 : return GDALGetCacheUsed();
4301 : }
4302 :
4303 :
4304 0 : void wrapper_GDALSetCacheMax(int nBytes)
4305 : {
4306 0 : return GDALSetCacheMax(nBytes);
4307 : }
4308 :
4309 :
4310 10 : const char *wrapper_GDALDecToDMS( double dfAngle, const char * pszAxis,
4311 : int nPrecision = 2 )
4312 : {
4313 10 : return GDALDecToDMS(dfAngle, pszAxis, nPrecision);
4314 : }
4315 :
4316 :
4317 0 : retStringAndCPLFree *GetJPEG2000StructureAsString( const char* pszFilename, char** options = NULL )
4318 : {
4319 0 : CPLXMLNode* psNode = GDALGetJPEG2000Structure(pszFilename, options);
4320 0 : if( psNode == NULL )
4321 0 : return NULL;
4322 0 : char* pszXML = CPLSerializeXMLTree(psNode);
4323 0 : CPLDestroyXMLNode(psNode);
4324 0 : return pszXML;
4325 : }
4326 :
4327 :
4328 0 : int GetDriverCount() {
4329 0 : return GDALGetDriverCount();
4330 : }
4331 :
4332 :
4333 : static
4334 8 : GDALDriverShadow* GetDriverByName( char const *name ) {
4335 8 : return (GDALDriverShadow*) GDALGetDriverByName( name );
4336 : }
4337 :
4338 :
4339 0 : GDALDriverShadow* GetDriver( int i ) {
4340 0 : return (GDALDriverShadow*) GDALGetDriver( i );
4341 : }
4342 :
4343 :
4344 : static
4345 5 : GDALDatasetShadow* Open( char const* utf8_path, GDALAccess eAccess) {
4346 5 : CPLErrorReset();
4347 5 : GDALDatasetShadow *ds = GDALOpen( utf8_path, eAccess );
4348 5 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
4349 : {
4350 0 : if ( GDALDereferenceDataset( ds ) <= 0 )
4351 0 : GDALClose(ds);
4352 0 : ds = NULL;
4353 : }
4354 5 : return (GDALDatasetShadow*) ds;
4355 : }
4356 :
4357 :
4358 2 : GDALDatasetShadow* Open( char const* name ) {
4359 2 : return Open( name, GA_ReadOnly );
4360 : }
4361 :
4362 :
4363 4 : GDALDatasetShadow* OpenEx( char const* utf8_path, unsigned int nOpenFlags = 0,
4364 : char** allowed_drivers = NULL, char** open_options = NULL,
4365 : char** sibling_files = NULL ) {
4366 4 : CPLErrorReset();
4367 : #ifdef SWIGPYTHON
4368 : if( GetUseExceptions() )
4369 : nOpenFlags |= GDAL_OF_VERBOSE_ERROR;
4370 : #endif
4371 4 : GDALDatasetShadow *ds = GDALOpenEx( utf8_path, nOpenFlags, allowed_drivers,
4372 : open_options, sibling_files );
4373 : #ifndef SWIGPYTHON
4374 4 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
4375 : {
4376 0 : if ( GDALDereferenceDataset( ds ) <= 0 )
4377 0 : GDALClose(ds);
4378 0 : ds = NULL;
4379 : }
4380 : #endif
4381 4 : return (GDALDatasetShadow*) ds;
4382 : }
4383 :
4384 :
4385 0 : GDALDatasetShadow* OpenShared( char const* utf8_path, GDALAccess eAccess = GA_ReadOnly ) {
4386 0 : CPLErrorReset();
4387 0 : GDALDatasetShadow *ds = GDALOpenShared( utf8_path, eAccess );
4388 : #ifndef SWIGPYTHON
4389 0 : if( ds != NULL && CPLGetLastErrorType() == CE_Failure )
4390 : {
4391 0 : if ( GDALDereferenceDataset( ds ) <= 0 )
4392 0 : GDALClose(ds);
4393 0 : ds = NULL;
4394 : }
4395 : #endif
4396 0 : return (GDALDatasetShadow*) ds;
4397 : }
4398 :
4399 :
4400 0 : GDALDriverShadow *IdentifyDriver( const char *utf8_path,
4401 : char **papszSiblings = NULL ) {
4402 0 : return (GDALDriverShadow *) GDALIdentifyDriver( utf8_path,
4403 0 : papszSiblings );
4404 : }
4405 :
4406 :
4407 0 : GDALDriverShadow *IdentifyDriverEx( const char* utf8_path,
4408 : unsigned int nIdentifyFlags = 0,
4409 : char** allowed_drivers = NULL,
4410 : char** sibling_files = NULL )
4411 : {
4412 0 : return (GDALDriverShadow *) GDALIdentifyDriverEx( utf8_path,
4413 : nIdentifyFlags,
4414 : allowed_drivers,
4415 0 : sibling_files );
4416 : }
4417 :
4418 :
4419 : static
4420 2 : char **GeneralCmdLineProcessor( char **papszArgv, int nOptions = 0 ) {
4421 : int nResArgCount;
4422 :
4423 : /* We must add a 'dummy' element in front of the real argument list */
4424 : /* as Java doesn't include the binary name as the first */
4425 : /* argument, as C does... */
4426 2 : char** papszArgvModBefore = CSLInsertString(CSLDuplicate(papszArgv), 0, "dummy");
4427 2 : char** papszArgvModAfter = papszArgvModBefore;
4428 :
4429 4 : bool bReloadDrivers = ( CSLFindString(papszArgv, "GDAL_SKIP") >= 0 ||
4430 2 : CSLFindString(papszArgv, "OGR_SKIP") >= 0 );
4431 :
4432 : nResArgCount =
4433 2 : GDALGeneralCmdLineProcessor( CSLCount(papszArgvModBefore), &papszArgvModAfter, nOptions );
4434 :
4435 2 : CSLDestroy(papszArgvModBefore);
4436 :
4437 2 : if( bReloadDrivers )
4438 : {
4439 0 : GDALAllRegister();
4440 : }
4441 :
4442 2 : if( nResArgCount <= 0 )
4443 : {
4444 0 : return NULL;
4445 : }
4446 : else
4447 : {
4448 : /* Now, remove the first dummy element */
4449 2 : char** papszRet = CSLDuplicate(papszArgvModAfter + 1);
4450 2 : CSLDestroy(papszArgvModAfter);
4451 2 : return papszRet;
4452 : }
4453 : }
4454 :
4455 :
4456 : #include "gdal_utils.h"
4457 :
4458 0 : SWIGINTERN GDALInfoOptions *new_GDALInfoOptions(char **options){
4459 0 : return GDALInfoOptionsNew(options, NULL);
4460 : }
4461 0 : SWIGINTERN void delete_GDALInfoOptions(GDALInfoOptions *self){
4462 0 : GDALInfoOptionsFree( self );
4463 0 : }
4464 0 : SWIGINTERN GDALVectorInfoOptions *new_GDALVectorInfoOptions(char **options){
4465 0 : return GDALVectorInfoOptionsNew(options, NULL);
4466 : }
4467 0 : SWIGINTERN void delete_GDALVectorInfoOptions(GDALVectorInfoOptions *self){
4468 0 : GDALVectorInfoOptionsFree( self );
4469 0 : }
4470 0 : SWIGINTERN GDALMultiDimInfoOptions *new_GDALMultiDimInfoOptions(char **options){
4471 0 : return GDALMultiDimInfoOptionsNew(options, NULL);
4472 : }
4473 0 : SWIGINTERN void delete_GDALMultiDimInfoOptions(GDALMultiDimInfoOptions *self){
4474 0 : GDALMultiDimInfoOptionsFree( self );
4475 0 : }
4476 0 : SWIGINTERN GDALTranslateOptions *new_GDALTranslateOptions(char **options){
4477 0 : return GDALTranslateOptionsNew(options, NULL);
4478 : }
4479 0 : SWIGINTERN void delete_GDALTranslateOptions(GDALTranslateOptions *self){
4480 0 : GDALTranslateOptionsFree( self );
4481 0 : }
4482 :
4483 0 : GDALDatasetShadow* wrapper_GDALTranslate( const char* dest,
4484 : GDALDatasetShadow* dataset,
4485 : GDALTranslateOptions* translateOptions,
4486 : GDALProgressFunc callback=NULL,
4487 : void* callback_data=NULL)
4488 : {
4489 : int usageError; /* ignored */
4490 0 : bool bFreeOptions = false;
4491 0 : if( callback )
4492 : {
4493 0 : if( translateOptions == NULL )
4494 : {
4495 0 : bFreeOptions = true;
4496 0 : translateOptions = GDALTranslateOptionsNew(NULL, NULL);
4497 : }
4498 0 : GDALTranslateOptionsSetProgress(translateOptions, callback, callback_data);
4499 : }
4500 : #ifdef SWIGPYTHON
4501 : std::vector<ErrorStruct> aoErrors;
4502 : if( GetUseExceptions() )
4503 : {
4504 : PushStackingErrorHandler(&aoErrors);
4505 : }
4506 : #endif
4507 0 : GDALDatasetH hDSRet = GDALTranslate(dest, dataset, translateOptions, &usageError);
4508 0 : if( bFreeOptions )
4509 0 : GDALTranslateOptionsFree(translateOptions);
4510 : #ifdef SWIGPYTHON
4511 : if( GetUseExceptions() )
4512 : {
4513 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4514 : }
4515 : #endif
4516 0 : return hDSRet;
4517 : }
4518 :
4519 0 : SWIGINTERN GDALWarpAppOptions *new_GDALWarpAppOptions(char **options){
4520 0 : return GDALWarpAppOptionsNew(options, NULL);
4521 : }
4522 0 : SWIGINTERN void delete_GDALWarpAppOptions(GDALWarpAppOptions *self){
4523 0 : GDALWarpAppOptionsFree( self );
4524 0 : }
4525 :
4526 :
4527 0 : int wrapper_GDALWarpDestDS( GDALDatasetShadow* dstDS,
4528 : int object_list_count, GDALDatasetShadow** poObjects,
4529 : GDALWarpAppOptions* warpAppOptions,
4530 : GDALProgressFunc callback=NULL,
4531 : void* callback_data=NULL)
4532 : {
4533 : int usageError; /* ignored */
4534 0 : bool bFreeOptions = false;
4535 0 : if( callback )
4536 : {
4537 0 : if( warpAppOptions == NULL )
4538 : {
4539 0 : bFreeOptions = true;
4540 0 : warpAppOptions = GDALWarpAppOptionsNew(NULL, NULL);
4541 : }
4542 0 : GDALWarpAppOptionsSetProgress(warpAppOptions, callback, callback_data);
4543 : }
4544 : #ifdef SWIGPYTHON
4545 : std::vector<ErrorStruct> aoErrors;
4546 : if( GetUseExceptions() )
4547 : {
4548 : PushStackingErrorHandler(&aoErrors);
4549 : }
4550 : #endif
4551 0 : bool bRet = (GDALWarp(NULL, dstDS, object_list_count, poObjects, warpAppOptions, &usageError) != NULL);
4552 0 : if( bFreeOptions )
4553 0 : GDALWarpAppOptionsFree(warpAppOptions);
4554 : #ifdef SWIGPYTHON
4555 : if( GetUseExceptions() )
4556 : {
4557 : PopStackingErrorHandler(&aoErrors, bRet);
4558 : }
4559 : #endif
4560 0 : return bRet;
4561 : }
4562 :
4563 :
4564 0 : GDALDatasetShadow* wrapper_GDALWarpDestName( const char* dest,
4565 : int object_list_count, GDALDatasetShadow** poObjects,
4566 : GDALWarpAppOptions* warpAppOptions,
4567 : GDALProgressFunc callback=NULL,
4568 : void* callback_data=NULL)
4569 : {
4570 : int usageError; /* ignored */
4571 0 : bool bFreeOptions = false;
4572 0 : if( callback )
4573 : {
4574 0 : if( warpAppOptions == NULL )
4575 : {
4576 0 : bFreeOptions = true;
4577 0 : warpAppOptions = GDALWarpAppOptionsNew(NULL, NULL);
4578 : }
4579 0 : GDALWarpAppOptionsSetProgress(warpAppOptions, callback, callback_data);
4580 : }
4581 : #ifdef SWIGPYTHON
4582 : std::vector<ErrorStruct> aoErrors;
4583 : if( GetUseExceptions() )
4584 : {
4585 : PushStackingErrorHandler(&aoErrors);
4586 : }
4587 : #endif
4588 0 : GDALDatasetH hDSRet = GDALWarp(dest, NULL, object_list_count, poObjects, warpAppOptions, &usageError);
4589 0 : if( bFreeOptions )
4590 0 : GDALWarpAppOptionsFree(warpAppOptions);
4591 : #ifdef SWIGPYTHON
4592 : if( GetUseExceptions() )
4593 : {
4594 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4595 : }
4596 : #endif
4597 0 : return hDSRet;
4598 : }
4599 :
4600 2 : SWIGINTERN GDALVectorTranslateOptions *new_GDALVectorTranslateOptions(char **options){
4601 2 : return GDALVectorTranslateOptionsNew(options, NULL);
4602 : }
4603 0 : SWIGINTERN void delete_GDALVectorTranslateOptions(GDALVectorTranslateOptions *self){
4604 0 : GDALVectorTranslateOptionsFree( self );
4605 0 : }
4606 :
4607 1 : int wrapper_GDALVectorTranslateDestDS( GDALDatasetShadow* dstDS,
4608 : GDALDatasetShadow* srcDS,
4609 : GDALVectorTranslateOptions* options,
4610 : GDALProgressFunc callback=NULL,
4611 : void* callback_data=NULL)
4612 : {
4613 : int usageError; /* ignored */
4614 1 : bool bFreeOptions = false;
4615 1 : if( callback )
4616 : {
4617 0 : if( options == NULL )
4618 : {
4619 0 : bFreeOptions = true;
4620 0 : options = GDALVectorTranslateOptionsNew(NULL, NULL);
4621 : }
4622 0 : GDALVectorTranslateOptionsSetProgress(options, callback, callback_data);
4623 : }
4624 : #ifdef SWIGPYTHON
4625 : std::vector<ErrorStruct> aoErrors;
4626 : if( GetUseExceptions() )
4627 : {
4628 : PushStackingErrorHandler(&aoErrors);
4629 : }
4630 : #endif
4631 1 : bool bRet = (GDALVectorTranslate(NULL, dstDS, 1, &srcDS, options, &usageError) != NULL);
4632 1 : if( bFreeOptions )
4633 0 : GDALVectorTranslateOptionsFree(options);
4634 : #ifdef SWIGPYTHON
4635 : if( GetUseExceptions() )
4636 : {
4637 : PopStackingErrorHandler(&aoErrors, bRet);
4638 : }
4639 : #endif
4640 1 : return bRet;
4641 : }
4642 :
4643 :
4644 1 : GDALDatasetShadow* wrapper_GDALVectorTranslateDestName( const char* dest,
4645 : GDALDatasetShadow* srcDS,
4646 : GDALVectorTranslateOptions* options,
4647 : GDALProgressFunc callback=NULL,
4648 : void* callback_data=NULL)
4649 : {
4650 : int usageError; /* ignored */
4651 1 : bool bFreeOptions = false;
4652 1 : if( callback )
4653 : {
4654 0 : if( options == NULL )
4655 : {
4656 0 : bFreeOptions = true;
4657 0 : options = GDALVectorTranslateOptionsNew(NULL, NULL);
4658 : }
4659 0 : GDALVectorTranslateOptionsSetProgress(options, callback, callback_data);
4660 : }
4661 : #ifdef SWIGPYTHON
4662 : std::vector<ErrorStruct> aoErrors;
4663 : if( GetUseExceptions() )
4664 : {
4665 : PushStackingErrorHandler(&aoErrors);
4666 : }
4667 : #endif
4668 1 : GDALDatasetH hDSRet = GDALVectorTranslate(dest, NULL, 1, &srcDS, options, &usageError);
4669 1 : if( bFreeOptions )
4670 0 : GDALVectorTranslateOptionsFree(options);
4671 : #ifdef SWIGPYTHON
4672 : if( GetUseExceptions() )
4673 : {
4674 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4675 : }
4676 : #endif
4677 1 : return hDSRet;
4678 : }
4679 :
4680 0 : SWIGINTERN GDALDEMProcessingOptions *new_GDALDEMProcessingOptions(char **options){
4681 0 : return GDALDEMProcessingOptionsNew(options, NULL);
4682 : }
4683 0 : SWIGINTERN void delete_GDALDEMProcessingOptions(GDALDEMProcessingOptions *self){
4684 0 : GDALDEMProcessingOptionsFree( self );
4685 0 : }
4686 :
4687 0 : GDALDatasetShadow* wrapper_GDALDEMProcessing( const char* dest,
4688 : GDALDatasetShadow* dataset,
4689 : const char* pszProcessing,
4690 : const char* pszColorFilename,
4691 : GDALDEMProcessingOptions* options,
4692 : GDALProgressFunc callback=NULL,
4693 : void* callback_data=NULL)
4694 : {
4695 : int usageError; /* ignored */
4696 0 : bool bFreeOptions = false;
4697 0 : if( callback )
4698 : {
4699 0 : if( options == NULL )
4700 : {
4701 0 : bFreeOptions = true;
4702 0 : options = GDALDEMProcessingOptionsNew(NULL, NULL);
4703 : }
4704 0 : GDALDEMProcessingOptionsSetProgress(options, callback, callback_data);
4705 : }
4706 : #ifdef SWIGPYTHON
4707 : std::vector<ErrorStruct> aoErrors;
4708 : if( GetUseExceptions() )
4709 : {
4710 : PushStackingErrorHandler(&aoErrors);
4711 : }
4712 : #endif
4713 0 : GDALDatasetH hDSRet = GDALDEMProcessing(dest, dataset, pszProcessing, pszColorFilename, options, &usageError);
4714 0 : if( bFreeOptions )
4715 0 : GDALDEMProcessingOptionsFree(options);
4716 : #ifdef SWIGPYTHON
4717 : if( GetUseExceptions() )
4718 : {
4719 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4720 : }
4721 : #endif
4722 0 : return hDSRet;
4723 : }
4724 :
4725 0 : SWIGINTERN GDALNearblackOptions *new_GDALNearblackOptions(char **options){
4726 0 : return GDALNearblackOptionsNew(options, NULL);
4727 : }
4728 0 : SWIGINTERN void delete_GDALNearblackOptions(GDALNearblackOptions *self){
4729 0 : GDALNearblackOptionsFree( self );
4730 0 : }
4731 :
4732 0 : int wrapper_GDALNearblackDestDS( GDALDatasetShadow* dstDS,
4733 : GDALDatasetShadow* srcDS,
4734 : GDALNearblackOptions* options,
4735 : GDALProgressFunc callback=NULL,
4736 : void* callback_data=NULL)
4737 : {
4738 : int usageError; /* ignored */
4739 0 : bool bFreeOptions = false;
4740 0 : if( callback )
4741 : {
4742 0 : if( options == NULL )
4743 : {
4744 0 : bFreeOptions = true;
4745 0 : options = GDALNearblackOptionsNew(NULL, NULL);
4746 : }
4747 0 : GDALNearblackOptionsSetProgress(options, callback, callback_data);
4748 : }
4749 : #ifdef SWIGPYTHON
4750 : std::vector<ErrorStruct> aoErrors;
4751 : if( GetUseExceptions() )
4752 : {
4753 : PushStackingErrorHandler(&aoErrors);
4754 : }
4755 : #endif
4756 0 : bool bRet = (GDALNearblack(NULL, dstDS, srcDS, options, &usageError) != NULL);
4757 0 : if( bFreeOptions )
4758 0 : GDALNearblackOptionsFree(options);
4759 : #ifdef SWIGPYTHON
4760 : if( GetUseExceptions() )
4761 : {
4762 : PopStackingErrorHandler(&aoErrors, bRet);
4763 : }
4764 : #endif
4765 0 : return bRet;
4766 : }
4767 :
4768 :
4769 0 : GDALDatasetShadow* wrapper_GDALNearblackDestName( const char* dest,
4770 : GDALDatasetShadow* srcDS,
4771 : GDALNearblackOptions* options,
4772 : GDALProgressFunc callback=NULL,
4773 : void* callback_data=NULL)
4774 : {
4775 : int usageError; /* ignored */
4776 0 : bool bFreeOptions = false;
4777 0 : if( callback )
4778 : {
4779 0 : if( options == NULL )
4780 : {
4781 0 : bFreeOptions = true;
4782 0 : options = GDALNearblackOptionsNew(NULL, NULL);
4783 : }
4784 0 : GDALNearblackOptionsSetProgress(options, callback, callback_data);
4785 : }
4786 : #ifdef SWIGPYTHON
4787 : std::vector<ErrorStruct> aoErrors;
4788 : if( GetUseExceptions() )
4789 : {
4790 : PushStackingErrorHandler(&aoErrors);
4791 : }
4792 : #endif
4793 0 : GDALDatasetH hDSRet = GDALNearblack(dest, NULL, srcDS, options, &usageError);
4794 0 : if( bFreeOptions )
4795 0 : GDALNearblackOptionsFree(options);
4796 : #ifdef SWIGPYTHON
4797 : if( GetUseExceptions() )
4798 : {
4799 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4800 : }
4801 : #endif
4802 0 : return hDSRet;
4803 : }
4804 :
4805 0 : SWIGINTERN GDALGridOptions *new_GDALGridOptions(char **options){
4806 0 : return GDALGridOptionsNew(options, NULL);
4807 : }
4808 0 : SWIGINTERN void delete_GDALGridOptions(GDALGridOptions *self){
4809 0 : GDALGridOptionsFree( self );
4810 0 : }
4811 :
4812 0 : GDALDatasetShadow* wrapper_GDALGrid( const char* dest,
4813 : GDALDatasetShadow* dataset,
4814 : GDALGridOptions* options,
4815 : GDALProgressFunc callback=NULL,
4816 : void* callback_data=NULL)
4817 : {
4818 : int usageError; /* ignored */
4819 0 : bool bFreeOptions = false;
4820 0 : if( callback )
4821 : {
4822 0 : if( options == NULL )
4823 : {
4824 0 : bFreeOptions = true;
4825 0 : options = GDALGridOptionsNew(NULL, NULL);
4826 : }
4827 0 : GDALGridOptionsSetProgress(options, callback, callback_data);
4828 : }
4829 : #ifdef SWIGPYTHON
4830 : std::vector<ErrorStruct> aoErrors;
4831 : if( GetUseExceptions() )
4832 : {
4833 : PushStackingErrorHandler(&aoErrors);
4834 : }
4835 : #endif
4836 0 : GDALDatasetH hDSRet = GDALGrid(dest, dataset, options, &usageError);
4837 0 : if( bFreeOptions )
4838 0 : GDALGridOptionsFree(options);
4839 : #ifdef SWIGPYTHON
4840 : if( GetUseExceptions() )
4841 : {
4842 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4843 : }
4844 : #endif
4845 0 : return hDSRet;
4846 : }
4847 :
4848 0 : SWIGINTERN GDALRasterizeOptions *new_GDALRasterizeOptions(char **options){
4849 0 : return GDALRasterizeOptionsNew(options, NULL);
4850 : }
4851 0 : SWIGINTERN void delete_GDALRasterizeOptions(GDALRasterizeOptions *self){
4852 0 : GDALRasterizeOptionsFree( self );
4853 0 : }
4854 :
4855 0 : int wrapper_GDALRasterizeDestDS( GDALDatasetShadow* dstDS,
4856 : GDALDatasetShadow* srcDS,
4857 : GDALRasterizeOptions* options,
4858 : GDALProgressFunc callback=NULL,
4859 : void* callback_data=NULL)
4860 : {
4861 : int usageError; /* ignored */
4862 0 : bool bFreeOptions = false;
4863 0 : if( callback )
4864 : {
4865 0 : if( options == NULL )
4866 : {
4867 0 : bFreeOptions = true;
4868 0 : options = GDALRasterizeOptionsNew(NULL, NULL);
4869 : }
4870 0 : GDALRasterizeOptionsSetProgress(options, callback, callback_data);
4871 : }
4872 : #ifdef SWIGPYTHON
4873 : std::vector<ErrorStruct> aoErrors;
4874 : if( GetUseExceptions() )
4875 : {
4876 : PushStackingErrorHandler(&aoErrors);
4877 : }
4878 : #endif
4879 0 : bool bRet = (GDALRasterize(NULL, dstDS, srcDS, options, &usageError) != NULL);
4880 0 : if( bFreeOptions )
4881 0 : GDALRasterizeOptionsFree(options);
4882 : #ifdef SWIGPYTHON
4883 : if( GetUseExceptions() )
4884 : {
4885 : PopStackingErrorHandler(&aoErrors, bRet);
4886 : }
4887 : #endif
4888 0 : return bRet;
4889 : }
4890 :
4891 :
4892 0 : GDALDatasetShadow* wrapper_GDALRasterizeDestName( const char* dest,
4893 : GDALDatasetShadow* srcDS,
4894 : GDALRasterizeOptions* options,
4895 : GDALProgressFunc callback=NULL,
4896 : void* callback_data=NULL)
4897 : {
4898 : int usageError; /* ignored */
4899 0 : bool bFreeOptions = false;
4900 0 : if( callback )
4901 : {
4902 0 : if( options == NULL )
4903 : {
4904 0 : bFreeOptions = true;
4905 0 : options = GDALRasterizeOptionsNew(NULL, NULL);
4906 : }
4907 0 : GDALRasterizeOptionsSetProgress(options, callback, callback_data);
4908 : }
4909 : #ifdef SWIGPYTHON
4910 : std::vector<ErrorStruct> aoErrors;
4911 : if( GetUseExceptions() )
4912 : {
4913 : PushStackingErrorHandler(&aoErrors);
4914 : }
4915 : #endif
4916 0 : GDALDatasetH hDSRet = GDALRasterize(dest, NULL, srcDS, options, &usageError);
4917 0 : if( bFreeOptions )
4918 0 : GDALRasterizeOptionsFree(options);
4919 : #ifdef SWIGPYTHON
4920 : if( GetUseExceptions() )
4921 : {
4922 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
4923 : }
4924 : #endif
4925 0 : return hDSRet;
4926 : }
4927 :
4928 0 : SWIGINTERN GDALFootprintOptions *new_GDALFootprintOptions(char **options){
4929 0 : return GDALFootprintOptionsNew(options, NULL);
4930 : }
4931 0 : SWIGINTERN void delete_GDALFootprintOptions(GDALFootprintOptions *self){
4932 0 : GDALFootprintOptionsFree( self );
4933 0 : }
4934 :
4935 0 : int wrapper_GDALFootprintDestDS( GDALDatasetShadow* dstDS,
4936 : GDALDatasetShadow* srcDS,
4937 : GDALFootprintOptions* options,
4938 : GDALProgressFunc callback=NULL,
4939 : void* callback_data=NULL)
4940 : {
4941 : int usageError; /* ignored */
4942 0 : bool bFreeOptions = false;
4943 0 : if( callback )
4944 : {
4945 0 : if( options == NULL )
4946 : {
4947 0 : bFreeOptions = true;
4948 0 : options = GDALFootprintOptionsNew(NULL, NULL);
4949 : }
4950 0 : GDALFootprintOptionsSetProgress(options, callback, callback_data);
4951 : }
4952 : #ifdef SWIGPYTHON
4953 : std::vector<ErrorStruct> aoErrors;
4954 : if( GetUseExceptions() )
4955 : {
4956 : PushStackingErrorHandler(&aoErrors);
4957 : }
4958 : #endif
4959 0 : bool bRet = (GDALFootprint(NULL, dstDS, srcDS, options, &usageError) != NULL);
4960 0 : if( bFreeOptions )
4961 0 : GDALFootprintOptionsFree(options);
4962 : #ifdef SWIGPYTHON
4963 : if( GetUseExceptions() )
4964 : {
4965 : PopStackingErrorHandler(&aoErrors, bRet);
4966 : }
4967 : #endif
4968 0 : return bRet;
4969 : }
4970 :
4971 :
4972 0 : GDALDatasetShadow* wrapper_GDALFootprintDestName( const char* dest,
4973 : GDALDatasetShadow* srcDS,
4974 : GDALFootprintOptions* options,
4975 : GDALProgressFunc callback=NULL,
4976 : void* callback_data=NULL)
4977 : {
4978 : int usageError; /* ignored */
4979 0 : bool bFreeOptions = false;
4980 0 : if( callback )
4981 : {
4982 0 : if( options == NULL )
4983 : {
4984 0 : bFreeOptions = true;
4985 0 : options = GDALFootprintOptionsNew(NULL, NULL);
4986 : }
4987 0 : GDALFootprintOptionsSetProgress(options, callback, callback_data);
4988 : }
4989 : #ifdef SWIGPYTHON
4990 : std::vector<ErrorStruct> aoErrors;
4991 : if( GetUseExceptions() )
4992 : {
4993 : PushStackingErrorHandler(&aoErrors);
4994 : }
4995 : #endif
4996 0 : GDALDatasetH hDSRet = GDALFootprint(dest, NULL, srcDS, options, &usageError);
4997 0 : if( bFreeOptions )
4998 0 : GDALFootprintOptionsFree(options);
4999 : #ifdef SWIGPYTHON
5000 : if( GetUseExceptions() )
5001 : {
5002 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
5003 : }
5004 : #endif
5005 0 : return hDSRet;
5006 : }
5007 :
5008 0 : SWIGINTERN GDALBuildVRTOptions *new_GDALBuildVRTOptions(char **options){
5009 0 : return GDALBuildVRTOptionsNew(options, NULL);
5010 : }
5011 0 : SWIGINTERN void delete_GDALBuildVRTOptions(GDALBuildVRTOptions *self){
5012 0 : GDALBuildVRTOptionsFree( self );
5013 0 : }
5014 :
5015 0 : GDALDatasetShadow* wrapper_GDALBuildVRT_objects( const char* dest,
5016 : int object_list_count, GDALDatasetShadow** poObjects,
5017 : GDALBuildVRTOptions* options,
5018 : GDALProgressFunc callback=NULL,
5019 : void* callback_data=NULL)
5020 : {
5021 : int usageError; /* ignored */
5022 0 : bool bFreeOptions = false;
5023 0 : if( callback )
5024 : {
5025 0 : if( options == NULL )
5026 : {
5027 0 : bFreeOptions = true;
5028 0 : options = GDALBuildVRTOptionsNew(NULL, NULL);
5029 : }
5030 0 : GDALBuildVRTOptionsSetProgress(options, callback, callback_data);
5031 : }
5032 : #ifdef SWIGPYTHON
5033 : std::vector<ErrorStruct> aoErrors;
5034 : if( GetUseExceptions() )
5035 : {
5036 : PushStackingErrorHandler(&aoErrors);
5037 : }
5038 : #endif
5039 0 : GDALDatasetH hDSRet = GDALBuildVRT(dest, object_list_count, poObjects, NULL, options, &usageError);
5040 0 : if( bFreeOptions )
5041 0 : GDALBuildVRTOptionsFree(options);
5042 : #ifdef SWIGPYTHON
5043 : if( GetUseExceptions() )
5044 : {
5045 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
5046 : }
5047 : #endif
5048 0 : return hDSRet;
5049 : }
5050 :
5051 :
5052 0 : GDALDatasetShadow* wrapper_GDALBuildVRT_names( const char* dest,
5053 : char ** source_filenames,
5054 : GDALBuildVRTOptions* options,
5055 : GDALProgressFunc callback=NULL,
5056 : void* callback_data=NULL)
5057 : {
5058 : int usageError; /* ignored */
5059 0 : bool bFreeOptions = false;
5060 0 : if( callback )
5061 : {
5062 0 : if( options == NULL )
5063 : {
5064 0 : bFreeOptions = true;
5065 0 : options = GDALBuildVRTOptionsNew(NULL, NULL);
5066 : }
5067 0 : GDALBuildVRTOptionsSetProgress(options, callback, callback_data);
5068 : }
5069 : #ifdef SWIGPYTHON
5070 : std::vector<ErrorStruct> aoErrors;
5071 : if( GetUseExceptions() )
5072 : {
5073 : PushStackingErrorHandler(&aoErrors);
5074 : }
5075 : #endif
5076 0 : GDALDatasetH hDSRet = GDALBuildVRT(dest, CSLCount(source_filenames), NULL, source_filenames, options, &usageError);
5077 0 : if( bFreeOptions )
5078 0 : GDALBuildVRTOptionsFree(options);
5079 : #ifdef SWIGPYTHON
5080 : if( GetUseExceptions() )
5081 : {
5082 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
5083 : }
5084 : #endif
5085 0 : return hDSRet;
5086 : }
5087 :
5088 0 : SWIGINTERN GDALTileIndexOptions *new_GDALTileIndexOptions(char **options){
5089 0 : return GDALTileIndexOptionsNew(options, NULL);
5090 : }
5091 0 : SWIGINTERN void delete_GDALTileIndexOptions(GDALTileIndexOptions *self){
5092 0 : GDALTileIndexOptionsFree( self );
5093 0 : }
5094 :
5095 0 : GDALDatasetShadow* wrapper_TileIndex_names( const char* dest,
5096 : char ** source_filenames,
5097 : GDALTileIndexOptions* options,
5098 : GDALProgressFunc callback=NULL,
5099 : void* callback_data=NULL)
5100 : {
5101 : int usageError; /* ignored */
5102 : #if 0
5103 : bool bFreeOptions = false;
5104 : if( callback )
5105 : {
5106 : if( options == NULL )
5107 : {
5108 : bFreeOptions = true;
5109 : options = GDALTileIndexOptionsNew(NULL, NULL);
5110 : }
5111 : GDALTileIndexOptionsSetProgress(options, callback, callback_data);
5112 : }
5113 : #endif
5114 :
5115 : #ifdef SWIGPYTHON
5116 : std::vector<ErrorStruct> aoErrors;
5117 : if( GetUseExceptions() )
5118 : {
5119 : PushStackingErrorHandler(&aoErrors);
5120 : }
5121 : #endif
5122 0 : GDALDatasetH hDSRet = GDALTileIndex(dest, CSLCount(source_filenames), source_filenames, options, &usageError);
5123 : #if 0
5124 : if( bFreeOptions )
5125 : GDALTileIndexOptionsFree(options);
5126 : #endif
5127 : #ifdef SWIGPYTHON
5128 : if( GetUseExceptions() )
5129 : {
5130 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
5131 : }
5132 : #endif
5133 0 : return hDSRet;
5134 : }
5135 :
5136 0 : SWIGINTERN GDALMultiDimTranslateOptions *new_GDALMultiDimTranslateOptions(char **options){
5137 0 : return GDALMultiDimTranslateOptionsNew(options, NULL);
5138 : }
5139 0 : SWIGINTERN void delete_GDALMultiDimTranslateOptions(GDALMultiDimTranslateOptions *self){
5140 0 : GDALMultiDimTranslateOptionsFree( self );
5141 0 : }
5142 :
5143 0 : GDALDatasetShadow* wrapper_GDALMultiDimTranslateDestName( const char* dest,
5144 : int object_list_count, GDALDatasetShadow** poObjects,
5145 : GDALMultiDimTranslateOptions* multiDimTranslateOptions,
5146 : GDALProgressFunc callback=NULL,
5147 : void* callback_data=NULL)
5148 : {
5149 : int usageError; /* ignored */
5150 0 : bool bFreeOptions = false;
5151 0 : if( callback )
5152 : {
5153 0 : if( multiDimTranslateOptions == NULL )
5154 : {
5155 0 : bFreeOptions = true;
5156 0 : multiDimTranslateOptions = GDALMultiDimTranslateOptionsNew(NULL, NULL);
5157 : }
5158 0 : GDALMultiDimTranslateOptionsSetProgress(multiDimTranslateOptions, callback, callback_data);
5159 : }
5160 : #ifdef SWIGPYTHON
5161 : std::vector<ErrorStruct> aoErrors;
5162 : if( GetUseExceptions() )
5163 : {
5164 : PushStackingErrorHandler(&aoErrors);
5165 : }
5166 : #endif
5167 0 : GDALDatasetH hDSRet = GDALMultiDimTranslate(dest, NULL, object_list_count, poObjects, multiDimTranslateOptions, &usageError);
5168 0 : if( bFreeOptions )
5169 0 : GDALMultiDimTranslateOptionsFree(multiDimTranslateOptions);
5170 : #ifdef SWIGPYTHON
5171 : if( GetUseExceptions() )
5172 : {
5173 : PopStackingErrorHandler(&aoErrors, hDSRet != NULL);
5174 : }
5175 : #endif
5176 0 : return hDSRet;
5177 : }
5178 :
5179 :
5180 : #ifdef __cplusplus
5181 : extern "C" {
5182 : #endif
5183 :
5184 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_UseExceptions(JNIEnv *jenv, jclass jcls) {
5185 : (void)jenv;
5186 : (void)jcls;
5187 0 : UseExceptions();
5188 0 : }
5189 :
5190 :
5191 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_DontUseExceptions(JNIEnv *jenv, jclass jcls) {
5192 : (void)jenv;
5193 : (void)jcls;
5194 0 : DontUseExceptions();
5195 0 : }
5196 :
5197 :
5198 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_GetUseExceptions(JNIEnv *jenv, jclass jcls) {
5199 0 : jboolean jresult = 0 ;
5200 : bool result;
5201 :
5202 : (void)jenv;
5203 : (void)jcls;
5204 0 : result = (bool)GetUseExceptions();
5205 0 : jresult = (jboolean)result;
5206 0 : return jresult;
5207 : }
5208 :
5209 :
5210 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1ProgressCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {
5211 0 : ProgressCallback *arg1 = (ProgressCallback *) 0 ;
5212 :
5213 : (void)jenv;
5214 : (void)jcls;
5215 0 : arg1 = *(ProgressCallback **)&jarg1;
5216 0 : delete arg1;
5217 0 : }
5218 :
5219 :
5220 21 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ProgressCallback_1run(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jstring jarg3) {
5221 21 : jint jresult = 0 ;
5222 21 : ProgressCallback *arg1 = (ProgressCallback *) 0 ;
5223 : double arg2 ;
5224 21 : char *arg3 = (char *) 0 ;
5225 : int result;
5226 :
5227 : (void)jenv;
5228 : (void)jcls;
5229 : (void)jarg1_;
5230 21 : arg1 = *(ProgressCallback **)&jarg1;
5231 21 : arg2 = (double)jarg2;
5232 21 : arg3 = 0;
5233 21 : if (jarg3) {
5234 21 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
5235 21 : if (!arg3) return 0;
5236 : }
5237 21 : result = (int)(arg1)->run(arg2,(char const *)arg3);
5238 21 : jresult = (jint)result;
5239 21 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
5240 21 : return jresult;
5241 : }
5242 :
5243 :
5244 2 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1ProgressCallback(JNIEnv *jenv, jclass jcls) {
5245 2 : jlong jresult = 0 ;
5246 2 : ProgressCallback *result = 0 ;
5247 :
5248 : (void)jenv;
5249 : (void)jcls;
5250 2 : result = (ProgressCallback *)new ProgressCallback();
5251 2 : *(ProgressCallback **)&jresult = result;
5252 2 : return jresult;
5253 : }
5254 :
5255 :
5256 2 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1TermProgressCallback(JNIEnv *jenv, jclass jcls) {
5257 2 : jlong jresult = 0 ;
5258 2 : TermProgressCallback *result = 0 ;
5259 :
5260 : (void)jenv;
5261 : (void)jcls;
5262 2 : result = (TermProgressCallback *)new TermProgressCallback();
5263 2 : *(TermProgressCallback **)&jresult = result;
5264 2 : return jresult;
5265 : }
5266 :
5267 :
5268 15 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_TermProgressCallback_1run(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jstring jarg3) {
5269 15 : jint jresult = 0 ;
5270 15 : TermProgressCallback *arg1 = (TermProgressCallback *) 0 ;
5271 : double arg2 ;
5272 15 : char *arg3 = (char *) 0 ;
5273 : int result;
5274 :
5275 : (void)jenv;
5276 : (void)jcls;
5277 : (void)jarg1_;
5278 15 : arg1 = *(TermProgressCallback **)&jarg1;
5279 15 : arg2 = (double)jarg2;
5280 15 : arg3 = 0;
5281 15 : if (jarg3) {
5282 10 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
5283 10 : if (!arg3) return 0;
5284 : }
5285 15 : result = (int)(arg1)->run(arg2,(char const *)arg3);
5286 15 : jresult = (jint)result;
5287 15 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
5288 15 : return jresult;
5289 : }
5290 :
5291 :
5292 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1TermProgressCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {
5293 0 : TermProgressCallback *arg1 = (TermProgressCallback *) 0 ;
5294 :
5295 : (void)jenv;
5296 : (void)jcls;
5297 0 : arg1 = *(TermProgressCallback **)&jarg1;
5298 0 : delete arg1;
5299 0 : }
5300 :
5301 :
5302 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Debug(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5303 0 : char *arg1 = (char *) 0 ;
5304 0 : char *arg2 = (char *) 0 ;
5305 :
5306 : (void)jenv;
5307 : (void)jcls;
5308 0 : arg1 = 0;
5309 0 : if (jarg1) {
5310 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5311 0 : if (!arg1) return ;
5312 : }
5313 0 : arg2 = 0;
5314 0 : if (jarg2) {
5315 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5316 0 : if (!arg2) return ;
5317 : }
5318 : {
5319 0 : if (!arg2) {
5320 : {
5321 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
5322 : };
5323 : }
5324 : }
5325 0 : Debug((char const *)arg1,(char const *)arg2);
5326 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5327 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5328 : }
5329 :
5330 :
5331 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SetErrorHandler_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jlong jarg2) {
5332 0 : jint jresult = 0 ;
5333 : CPLErrorHandler arg1 ;
5334 0 : void *arg2 = (void *) 0 ;
5335 : CPLErrorHandler *argp1 ;
5336 : CPLErr result;
5337 :
5338 : (void)jenv;
5339 : (void)jcls;
5340 0 : argp1 = *(CPLErrorHandler **)&jarg1;
5341 0 : if (!argp1) {
5342 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null CPLErrorHandler");
5343 0 : return 0;
5344 : }
5345 0 : arg1 = *argp1;
5346 0 : arg2 = *(void **)&jarg2;
5347 0 : result = (CPLErr)SetErrorHandler(arg1,arg2);
5348 0 : jresult = (jint)result;
5349 0 : return jresult;
5350 : }
5351 :
5352 :
5353 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SetErrorHandler_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
5354 0 : jint jresult = 0 ;
5355 : CPLErrorHandler arg1 ;
5356 : CPLErrorHandler *argp1 ;
5357 : CPLErr result;
5358 :
5359 : (void)jenv;
5360 : (void)jcls;
5361 0 : argp1 = *(CPLErrorHandler **)&jarg1;
5362 0 : if (!argp1) {
5363 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null CPLErrorHandler");
5364 0 : return 0;
5365 : }
5366 0 : arg1 = *argp1;
5367 0 : result = (CPLErr)SetErrorHandler(arg1);
5368 0 : jresult = (jint)result;
5369 0 : return jresult;
5370 : }
5371 :
5372 :
5373 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SetErrorHandler_1_1SWIG_12(JNIEnv *jenv, jclass jcls) {
5374 0 : jint jresult = 0 ;
5375 : CPLErr result;
5376 :
5377 : (void)jenv;
5378 : (void)jcls;
5379 0 : result = (CPLErr)SetErrorHandler();
5380 0 : jresult = (jint)result;
5381 0 : return jresult;
5382 : }
5383 :
5384 :
5385 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetCurrentErrorHandlerCatchDebug(JNIEnv *jenv, jclass jcls, jint jarg1) {
5386 : int arg1 ;
5387 :
5388 : (void)jenv;
5389 : (void)jcls;
5390 0 : arg1 = (int)jarg1;
5391 0 : CPLSetCurrentErrorHandlerCatchDebug(arg1);
5392 0 : }
5393 :
5394 :
5395 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_PushErrorHandler_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) {
5396 1 : jint jresult = 0 ;
5397 1 : char *arg1 = (char *) 0 ;
5398 : CPLErr result;
5399 :
5400 : (void)jenv;
5401 : (void)jcls;
5402 1 : arg1 = 0;
5403 1 : if (jarg1) {
5404 1 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5405 1 : if (!arg1) return 0;
5406 : }
5407 1 : result = (CPLErr)PushErrorHandler((char const *)arg1);
5408 1 : jresult = (jint)result;
5409 1 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5410 1 : return jresult;
5411 : }
5412 :
5413 :
5414 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_PushErrorHandler_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
5415 0 : jint jresult = 0 ;
5416 : CPLErr result;
5417 :
5418 : (void)jenv;
5419 : (void)jcls;
5420 0 : result = (CPLErr)PushErrorHandler();
5421 0 : jresult = (jint)result;
5422 0 : return jresult;
5423 : }
5424 :
5425 :
5426 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Error(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jstring jarg3) {
5427 : CPLErr arg1 ;
5428 : int arg2 ;
5429 0 : char *arg3 = (char *) 0 ;
5430 :
5431 : (void)jenv;
5432 : (void)jcls;
5433 0 : arg1 = (CPLErr)jarg1;
5434 0 : arg2 = (int)jarg2;
5435 0 : arg3 = 0;
5436 0 : if (jarg3) {
5437 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
5438 0 : if (!arg3) return ;
5439 : }
5440 0 : Error(arg1,arg2,(char const *)arg3);
5441 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
5442 : }
5443 :
5444 :
5445 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GOA2GetAuthorizationURL(JNIEnv *jenv, jclass jcls, jstring jarg1) {
5446 0 : jstring jresult = 0 ;
5447 0 : char *arg1 = (char *) 0 ;
5448 0 : retStringAndCPLFree *result = 0 ;
5449 :
5450 : (void)jenv;
5451 : (void)jcls;
5452 0 : arg1 = 0;
5453 0 : if (jarg1) {
5454 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5455 0 : if (!arg1) return 0;
5456 : }
5457 : {
5458 0 : if (!arg1) {
5459 : {
5460 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5461 : };
5462 : }
5463 : }
5464 0 : result = (retStringAndCPLFree *)GOA2GetAuthorizationURL((char const *)arg1);
5465 : {
5466 : /* %typemap(out) (retStringAndCPLFree*) */
5467 0 : if(result)
5468 : {
5469 0 : jresult = jenv->NewStringUTF((const char *)result);
5470 0 : CPLFree(result);
5471 : }
5472 : }
5473 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5474 0 : return jresult;
5475 : }
5476 :
5477 :
5478 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GOA2GetRefreshToken(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5479 0 : jstring jresult = 0 ;
5480 0 : char *arg1 = (char *) 0 ;
5481 0 : char *arg2 = (char *) 0 ;
5482 0 : retStringAndCPLFree *result = 0 ;
5483 :
5484 : (void)jenv;
5485 : (void)jcls;
5486 0 : arg1 = 0;
5487 0 : if (jarg1) {
5488 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5489 0 : if (!arg1) return 0;
5490 : }
5491 0 : arg2 = 0;
5492 0 : if (jarg2) {
5493 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5494 0 : if (!arg2) return 0;
5495 : }
5496 : {
5497 0 : if (!arg1) {
5498 : {
5499 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5500 : };
5501 : }
5502 : }
5503 0 : result = (retStringAndCPLFree *)GOA2GetRefreshToken((char const *)arg1,(char const *)arg2);
5504 : {
5505 : /* %typemap(out) (retStringAndCPLFree*) */
5506 0 : if(result)
5507 : {
5508 0 : jresult = jenv->NewStringUTF((const char *)result);
5509 0 : CPLFree(result);
5510 : }
5511 : }
5512 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5513 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5514 0 : return jresult;
5515 : }
5516 :
5517 :
5518 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GOA2GetAccessToken(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5519 0 : jstring jresult = 0 ;
5520 0 : char *arg1 = (char *) 0 ;
5521 0 : char *arg2 = (char *) 0 ;
5522 0 : retStringAndCPLFree *result = 0 ;
5523 :
5524 : (void)jenv;
5525 : (void)jcls;
5526 0 : arg1 = 0;
5527 0 : if (jarg1) {
5528 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5529 0 : if (!arg1) return 0;
5530 : }
5531 0 : arg2 = 0;
5532 0 : if (jarg2) {
5533 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5534 0 : if (!arg2) return 0;
5535 : }
5536 : {
5537 0 : if (!arg1) {
5538 : {
5539 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5540 : };
5541 : }
5542 : }
5543 0 : result = (retStringAndCPLFree *)GOA2GetAccessToken((char const *)arg1,(char const *)arg2);
5544 : {
5545 : /* %typemap(out) (retStringAndCPLFree*) */
5546 0 : if(result)
5547 : {
5548 0 : jresult = jenv->NewStringUTF((const char *)result);
5549 0 : CPLFree(result);
5550 : }
5551 : }
5552 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5553 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5554 0 : return jresult;
5555 : }
5556 :
5557 :
5558 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_PopErrorHandler(JNIEnv *jenv, jclass jcls) {
5559 : (void)jenv;
5560 : (void)jcls;
5561 1 : CPLPopErrorHandler();
5562 1 : }
5563 :
5564 :
5565 22 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ErrorReset(JNIEnv *jenv, jclass jcls) {
5566 : (void)jenv;
5567 : (void)jcls;
5568 22 : CPLErrorReset();
5569 22 : }
5570 :
5571 :
5572 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_EscapeString_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jbyteArray jarg1, jint jarg3) {
5573 0 : jstring jresult = 0 ;
5574 : int arg1 ;
5575 0 : unsigned char *arg2 = (unsigned char *) 0 ;
5576 : int arg3 ;
5577 0 : retStringAndCPLFree *result = 0 ;
5578 :
5579 : (void)jenv;
5580 : (void)jcls;
5581 : {
5582 : /* %typemap(in) (int nLen, unsigned char *pBuf ) */
5583 0 : arg1 = 0;
5584 0 : arg2 = NULL;
5585 0 : if (jarg1)
5586 : {
5587 0 : arg1 = jenv->GetArrayLength(jarg1);
5588 0 : arg2 = (unsigned char *)jenv->GetByteArrayElements(jarg1, NULL);
5589 : }
5590 : }
5591 0 : arg3 = (int)jarg3;
5592 0 : result = (retStringAndCPLFree *)EscapeString(arg1,arg2,arg3);
5593 : {
5594 : /* %typemap(out) (retStringAndCPLFree*) */
5595 0 : if(result)
5596 : {
5597 0 : jresult = jenv->NewStringUTF((const char *)result);
5598 0 : CPLFree(result);
5599 : }
5600 : }
5601 : {
5602 : /* %typemap(argout) (int nLen, unsigned char *pBuf ) */
5603 : }
5604 : {
5605 : /* %typemap(freearg) (int nLen, unsigned char *pBuf ) */
5606 : /* This calls JNI_ABORT, so any modifications will not be passed back
5607 : into the Java caller
5608 : */
5609 0 : if(arg2) {
5610 0 : jenv->ReleaseByteArrayElements(jarg1, (jbyte *)arg2, JNI_ABORT);
5611 : }
5612 : }
5613 0 : return jresult;
5614 : }
5615 :
5616 :
5617 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_EscapeString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
5618 0 : jstring jresult = 0 ;
5619 0 : char *arg1 = (char *) 0 ;
5620 : int arg2 ;
5621 0 : retStringAndCPLFree *result = 0 ;
5622 :
5623 : (void)jenv;
5624 : (void)jcls;
5625 0 : arg1 = 0;
5626 0 : if (jarg1) {
5627 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5628 0 : if (!arg1) return 0;
5629 : }
5630 0 : arg2 = (int)jarg2;
5631 0 : result = (retStringAndCPLFree *)EscapeString((char const *)arg1,arg2);
5632 : {
5633 : /* %typemap(out) (retStringAndCPLFree*) */
5634 0 : if(result)
5635 : {
5636 0 : jresult = jenv->NewStringUTF((const char *)result);
5637 0 : CPLFree(result);
5638 : }
5639 : }
5640 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5641 0 : return jresult;
5642 : }
5643 :
5644 :
5645 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetLastErrorNo(JNIEnv *jenv, jclass jcls) {
5646 0 : jint jresult = 0 ;
5647 : int result;
5648 :
5649 : (void)jenv;
5650 : (void)jcls;
5651 0 : result = (int)CPLGetLastErrorNo();
5652 0 : jresult = (jint)result;
5653 0 : return jresult;
5654 : }
5655 :
5656 :
5657 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetLastErrorType(JNIEnv *jenv, jclass jcls) {
5658 0 : jint jresult = 0 ;
5659 : CPLErr result;
5660 :
5661 : (void)jenv;
5662 : (void)jcls;
5663 0 : result = (CPLErr)CPLGetLastErrorType();
5664 0 : jresult = (jint)result;
5665 0 : return jresult;
5666 : }
5667 :
5668 :
5669 2 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetLastErrorMsg(JNIEnv *jenv, jclass jcls) {
5670 2 : jstring jresult = 0 ;
5671 2 : char *result = 0 ;
5672 :
5673 : (void)jenv;
5674 : (void)jcls;
5675 2 : result = (char *)CPLGetLastErrorMsg();
5676 2 : if (result) jresult = jenv->NewStringUTF((const char *)result);
5677 2 : return jresult;
5678 : }
5679 :
5680 :
5681 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_GetErrorCounter(JNIEnv *jenv, jclass jcls) {
5682 0 : jlong jresult = 0 ;
5683 : unsigned int result;
5684 :
5685 : (void)jenv;
5686 : (void)jcls;
5687 0 : result = (unsigned int)CPLGetErrorCounter();
5688 0 : jresult = (jlong)result;
5689 0 : return jresult;
5690 : }
5691 :
5692 :
5693 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_VSIGetLastErrorNo(JNIEnv *jenv, jclass jcls) {
5694 0 : jint jresult = 0 ;
5695 : int result;
5696 :
5697 : (void)jenv;
5698 : (void)jcls;
5699 0 : result = (int)VSIGetLastErrorNo();
5700 0 : jresult = (jint)result;
5701 0 : return jresult;
5702 : }
5703 :
5704 :
5705 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_VSIGetLastErrorMsg(JNIEnv *jenv, jclass jcls) {
5706 0 : jstring jresult = 0 ;
5707 0 : char *result = 0 ;
5708 :
5709 : (void)jenv;
5710 : (void)jcls;
5711 0 : result = (char *)VSIGetLastErrorMsg();
5712 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
5713 0 : return jresult;
5714 : }
5715 :
5716 :
5717 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_VSIErrorReset(JNIEnv *jenv, jclass jcls) {
5718 : (void)jenv;
5719 : (void)jcls;
5720 0 : VSIErrorReset();
5721 0 : }
5722 :
5723 :
5724 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_PushFinderLocation(JNIEnv *jenv, jclass jcls, jstring jarg1) {
5725 0 : char *arg1 = (char *) 0 ;
5726 :
5727 : (void)jenv;
5728 : (void)jcls;
5729 0 : arg1 = 0;
5730 0 : if (jarg1) {
5731 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5732 0 : if (!arg1) return ;
5733 : }
5734 : {
5735 0 : if (!arg1) {
5736 : {
5737 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
5738 : };
5739 : }
5740 : }
5741 0 : CPLPushFinderLocation((char const *)arg1);
5742 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5743 : }
5744 :
5745 :
5746 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_PopFinderLocation(JNIEnv *jenv, jclass jcls) {
5747 : (void)jenv;
5748 : (void)jcls;
5749 0 : CPLPopFinderLocation();
5750 0 : }
5751 :
5752 :
5753 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_FinderClean(JNIEnv *jenv, jclass jcls) {
5754 : (void)jenv;
5755 : (void)jcls;
5756 0 : CPLFinderClean();
5757 0 : }
5758 :
5759 :
5760 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_FindFile(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5761 0 : jstring jresult = 0 ;
5762 0 : char *arg1 = (char *) 0 ;
5763 0 : char *arg2 = (char *) 0 ;
5764 0 : char *result = 0 ;
5765 :
5766 : (void)jenv;
5767 : (void)jcls;
5768 0 : arg1 = 0;
5769 0 : if (jarg1) {
5770 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5771 0 : if (!arg1) return 0;
5772 : }
5773 0 : arg2 = 0;
5774 0 : if (jarg2) {
5775 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5776 0 : if (!arg2) return 0;
5777 : }
5778 : {
5779 0 : if (!arg2) {
5780 : {
5781 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5782 : };
5783 : }
5784 : }
5785 0 : result = (char *)CPLFindFile((char const *)arg1,(char const *)arg2);
5786 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
5787 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5788 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5789 0 : return jresult;
5790 : }
5791 :
5792 :
5793 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_ReadDir_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
5794 0 : jobject jresult = 0 ;
5795 0 : char *arg1 = (char *) 0 ;
5796 : int arg2 ;
5797 0 : char **result = 0 ;
5798 :
5799 : (void)jenv;
5800 : (void)jcls;
5801 0 : arg1 = 0;
5802 0 : if (jarg1) {
5803 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5804 0 : if (!arg1) return 0;
5805 : }
5806 0 : arg2 = (int)jarg2;
5807 : {
5808 0 : if (!arg1) {
5809 : {
5810 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5811 : };
5812 : }
5813 : }
5814 0 : result = (char **)wrapper_VSIReadDirEx((char const *)arg1,arg2);
5815 : {
5816 : /* %typemap(out) char **CSL */
5817 0 : char **stringarray = result;
5818 0 : const jclass vector = jenv->FindClass("java/util/Vector");
5819 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
5820 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
5821 :
5822 0 : jresult = jenv->NewObject(vector, constructor);
5823 0 : if ( stringarray != NULL ) {
5824 0 : while(*stringarray != NULL) {
5825 : /*printf("working on string %s\n", *stringarray);*/
5826 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
5827 0 : jenv->CallBooleanMethod(jresult, add, value);
5828 0 : jenv->DeleteLocalRef(value);
5829 0 : stringarray++;
5830 : }
5831 : }
5832 0 : CSLDestroy(result);
5833 : }
5834 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5835 0 : return jresult;
5836 : }
5837 :
5838 :
5839 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_ReadDir_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
5840 0 : jobject jresult = 0 ;
5841 0 : char *arg1 = (char *) 0 ;
5842 0 : char **result = 0 ;
5843 :
5844 : (void)jenv;
5845 : (void)jcls;
5846 0 : arg1 = 0;
5847 0 : if (jarg1) {
5848 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5849 0 : if (!arg1) return 0;
5850 : }
5851 : {
5852 0 : if (!arg1) {
5853 : {
5854 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5855 : };
5856 : }
5857 : }
5858 0 : result = (char **)wrapper_VSIReadDirEx((char const *)arg1);
5859 : {
5860 : /* %typemap(out) char **CSL */
5861 0 : char **stringarray = result;
5862 0 : const jclass vector = jenv->FindClass("java/util/Vector");
5863 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
5864 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
5865 :
5866 0 : jresult = jenv->NewObject(vector, constructor);
5867 0 : if ( stringarray != NULL ) {
5868 0 : while(*stringarray != NULL) {
5869 : /*printf("working on string %s\n", *stringarray);*/
5870 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
5871 0 : jenv->CallBooleanMethod(jresult, add, value);
5872 0 : jenv->DeleteLocalRef(value);
5873 0 : stringarray++;
5874 : }
5875 : }
5876 0 : CSLDestroy(result);
5877 : }
5878 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5879 0 : return jresult;
5880 : }
5881 :
5882 :
5883 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_ReadDirRecursive(JNIEnv *jenv, jclass jcls, jstring jarg1) {
5884 0 : jobject jresult = 0 ;
5885 0 : char *arg1 = (char *) 0 ;
5886 0 : char **result = 0 ;
5887 :
5888 : (void)jenv;
5889 : (void)jcls;
5890 0 : arg1 = 0;
5891 0 : if (jarg1) {
5892 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5893 0 : if (!arg1) return 0;
5894 : }
5895 : {
5896 0 : if (!arg1) {
5897 : {
5898 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
5899 : };
5900 : }
5901 : }
5902 0 : result = (char **)VSIReadDirRecursive((char const *)arg1);
5903 : {
5904 : /* %typemap(out) char **CSL */
5905 0 : char **stringarray = result;
5906 0 : const jclass vector = jenv->FindClass("java/util/Vector");
5907 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
5908 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
5909 :
5910 0 : jresult = jenv->NewObject(vector, constructor);
5911 0 : if ( stringarray != NULL ) {
5912 0 : while(*stringarray != NULL) {
5913 : /*printf("working on string %s\n", *stringarray);*/
5914 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
5915 0 : jenv->CallBooleanMethod(jresult, add, value);
5916 0 : jenv->DeleteLocalRef(value);
5917 0 : stringarray++;
5918 : }
5919 : }
5920 0 : CSLDestroy(result);
5921 : }
5922 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5923 0 : return jresult;
5924 : }
5925 :
5926 :
5927 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetConfigOption(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5928 0 : char *arg1 = (char *) 0 ;
5929 0 : char *arg2 = (char *) 0 ;
5930 :
5931 : (void)jenv;
5932 : (void)jcls;
5933 0 : arg1 = 0;
5934 0 : if (jarg1) {
5935 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5936 0 : if (!arg1) return ;
5937 : }
5938 0 : arg2 = 0;
5939 0 : if (jarg2) {
5940 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5941 0 : if (!arg2) return ;
5942 : }
5943 : {
5944 0 : if (!arg1) {
5945 : {
5946 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
5947 : };
5948 : }
5949 : }
5950 0 : CPLSetConfigOption((char const *)arg1,(char const *)arg2);
5951 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5952 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5953 : }
5954 :
5955 :
5956 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetThreadLocalConfigOption(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5957 0 : char *arg1 = (char *) 0 ;
5958 0 : char *arg2 = (char *) 0 ;
5959 :
5960 : (void)jenv;
5961 : (void)jcls;
5962 0 : arg1 = 0;
5963 0 : if (jarg1) {
5964 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5965 0 : if (!arg1) return ;
5966 : }
5967 0 : arg2 = 0;
5968 0 : if (jarg2) {
5969 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
5970 0 : if (!arg2) return ;
5971 : }
5972 : {
5973 0 : if (!arg1) {
5974 : {
5975 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
5976 : };
5977 : }
5978 : }
5979 0 : CPLSetThreadLocalConfigOption((char const *)arg1,(char const *)arg2);
5980 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
5981 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
5982 : }
5983 :
5984 :
5985 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetConfigOption_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
5986 0 : jstring jresult = 0 ;
5987 0 : char *arg1 = (char *) 0 ;
5988 0 : char *arg2 = (char *) 0 ;
5989 0 : char *result = 0 ;
5990 :
5991 : (void)jenv;
5992 : (void)jcls;
5993 0 : arg1 = 0;
5994 0 : if (jarg1) {
5995 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
5996 0 : if (!arg1) return 0;
5997 : }
5998 0 : arg2 = 0;
5999 0 : if (jarg2) {
6000 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6001 0 : if (!arg2) return 0;
6002 : }
6003 : {
6004 0 : if (!arg1) {
6005 : {
6006 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6007 : };
6008 : }
6009 : }
6010 0 : result = (char *)wrapper_CPLGetConfigOption((char const *)arg1,(char const *)arg2);
6011 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6012 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6013 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6014 0 : return jresult;
6015 : }
6016 :
6017 :
6018 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetConfigOption_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6019 0 : jstring jresult = 0 ;
6020 0 : char *arg1 = (char *) 0 ;
6021 0 : char *result = 0 ;
6022 :
6023 : (void)jenv;
6024 : (void)jcls;
6025 0 : arg1 = 0;
6026 0 : if (jarg1) {
6027 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6028 0 : if (!arg1) return 0;
6029 : }
6030 : {
6031 0 : if (!arg1) {
6032 : {
6033 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6034 : };
6035 : }
6036 : }
6037 0 : result = (char *)wrapper_CPLGetConfigOption((char const *)arg1);
6038 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6039 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6040 0 : return jresult;
6041 : }
6042 :
6043 :
6044 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetGlobalConfigOption_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
6045 0 : jstring jresult = 0 ;
6046 0 : char *arg1 = (char *) 0 ;
6047 0 : char *arg2 = (char *) 0 ;
6048 0 : char *result = 0 ;
6049 :
6050 : (void)jenv;
6051 : (void)jcls;
6052 0 : arg1 = 0;
6053 0 : if (jarg1) {
6054 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6055 0 : if (!arg1) return 0;
6056 : }
6057 0 : arg2 = 0;
6058 0 : if (jarg2) {
6059 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6060 0 : if (!arg2) return 0;
6061 : }
6062 : {
6063 0 : if (!arg1) {
6064 : {
6065 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6066 : };
6067 : }
6068 : }
6069 0 : result = (char *)wrapper_CPLGetGlobalConfigOption((char const *)arg1,(char const *)arg2);
6070 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6071 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6072 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6073 0 : return jresult;
6074 : }
6075 :
6076 :
6077 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetGlobalConfigOption_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6078 0 : jstring jresult = 0 ;
6079 0 : char *arg1 = (char *) 0 ;
6080 0 : char *result = 0 ;
6081 :
6082 : (void)jenv;
6083 : (void)jcls;
6084 0 : arg1 = 0;
6085 0 : if (jarg1) {
6086 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6087 0 : if (!arg1) return 0;
6088 : }
6089 : {
6090 0 : if (!arg1) {
6091 : {
6092 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6093 : };
6094 : }
6095 : }
6096 0 : result = (char *)wrapper_CPLGetGlobalConfigOption((char const *)arg1);
6097 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6098 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6099 0 : return jresult;
6100 : }
6101 :
6102 :
6103 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetThreadLocalConfigOption_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
6104 0 : jstring jresult = 0 ;
6105 0 : char *arg1 = (char *) 0 ;
6106 0 : char *arg2 = (char *) 0 ;
6107 0 : char *result = 0 ;
6108 :
6109 : (void)jenv;
6110 : (void)jcls;
6111 0 : arg1 = 0;
6112 0 : if (jarg1) {
6113 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6114 0 : if (!arg1) return 0;
6115 : }
6116 0 : arg2 = 0;
6117 0 : if (jarg2) {
6118 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6119 0 : if (!arg2) return 0;
6120 : }
6121 : {
6122 0 : if (!arg1) {
6123 : {
6124 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6125 : };
6126 : }
6127 : }
6128 0 : result = (char *)wrapper_CPLGetThreadLocalConfigOption((char const *)arg1,(char const *)arg2);
6129 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6130 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6131 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6132 0 : return jresult;
6133 : }
6134 :
6135 :
6136 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetThreadLocalConfigOption_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6137 0 : jstring jresult = 0 ;
6138 0 : char *arg1 = (char *) 0 ;
6139 0 : char *result = 0 ;
6140 :
6141 : (void)jenv;
6142 : (void)jcls;
6143 0 : arg1 = 0;
6144 0 : if (jarg1) {
6145 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6146 0 : if (!arg1) return 0;
6147 : }
6148 : {
6149 0 : if (!arg1) {
6150 : {
6151 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6152 : };
6153 : }
6154 : }
6155 0 : result = (char *)wrapper_CPLGetThreadLocalConfigOption((char const *)arg1);
6156 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6157 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6158 0 : return jresult;
6159 : }
6160 :
6161 :
6162 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_GetConfigOptions(JNIEnv *jenv, jclass jcls) {
6163 0 : jobject jresult = 0 ;
6164 0 : char **result = 0 ;
6165 :
6166 : (void)jenv;
6167 : (void)jcls;
6168 0 : result = (char **)wrapper_GetConfigOptions();
6169 : {
6170 : /* %typemap(out) char **dictAndCSLDestroy */
6171 0 : jresult = GetCSLStringAsHashTable(jenv, result, true);
6172 : }
6173 0 : return jresult;
6174 : }
6175 :
6176 :
6177 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetPathSpecificOption(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
6178 0 : char *arg1 = (char *) 0 ;
6179 0 : char *arg2 = (char *) 0 ;
6180 0 : char *arg3 = (char *) 0 ;
6181 :
6182 : (void)jenv;
6183 : (void)jcls;
6184 0 : arg1 = 0;
6185 0 : if (jarg1) {
6186 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6187 0 : if (!arg1) return ;
6188 : }
6189 0 : arg2 = 0;
6190 0 : if (jarg2) {
6191 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6192 0 : if (!arg2) return ;
6193 : }
6194 0 : arg3 = 0;
6195 0 : if (jarg3) {
6196 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
6197 0 : if (!arg3) return ;
6198 : }
6199 : {
6200 0 : if (!arg1) {
6201 : {
6202 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
6203 : };
6204 : }
6205 : }
6206 : {
6207 0 : if (!arg2) {
6208 : {
6209 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
6210 : };
6211 : }
6212 : }
6213 0 : VSISetPathSpecificOption((char const *)arg1,(char const *)arg2,(char const *)arg3);
6214 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6215 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6216 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
6217 : }
6218 :
6219 :
6220 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetCredential(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
6221 0 : char *arg1 = (char *) 0 ;
6222 0 : char *arg2 = (char *) 0 ;
6223 0 : char *arg3 = (char *) 0 ;
6224 :
6225 : (void)jenv;
6226 : (void)jcls;
6227 0 : arg1 = 0;
6228 0 : if (jarg1) {
6229 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6230 0 : if (!arg1) return ;
6231 : }
6232 0 : arg2 = 0;
6233 0 : if (jarg2) {
6234 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6235 0 : if (!arg2) return ;
6236 : }
6237 0 : arg3 = 0;
6238 0 : if (jarg3) {
6239 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
6240 0 : if (!arg3) return ;
6241 : }
6242 : {
6243 0 : if (!arg1) {
6244 : {
6245 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
6246 : };
6247 : }
6248 : }
6249 : {
6250 0 : if (!arg2) {
6251 : {
6252 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
6253 : };
6254 : }
6255 : }
6256 0 : wrapper_VSISetCredential((char const *)arg1,(char const *)arg2,(char const *)arg3);
6257 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6258 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6259 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
6260 : }
6261 :
6262 :
6263 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetCredential_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
6264 0 : jstring jresult = 0 ;
6265 0 : char *arg1 = (char *) 0 ;
6266 0 : char *arg2 = (char *) 0 ;
6267 0 : char *arg3 = (char *) 0 ;
6268 0 : char *result = 0 ;
6269 :
6270 : (void)jenv;
6271 : (void)jcls;
6272 0 : arg1 = 0;
6273 0 : if (jarg1) {
6274 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6275 0 : if (!arg1) return 0;
6276 : }
6277 0 : arg2 = 0;
6278 0 : if (jarg2) {
6279 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6280 0 : if (!arg2) return 0;
6281 : }
6282 0 : arg3 = 0;
6283 0 : if (jarg3) {
6284 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
6285 0 : if (!arg3) return 0;
6286 : }
6287 : {
6288 0 : if (!arg1) {
6289 : {
6290 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6291 : };
6292 : }
6293 : }
6294 : {
6295 0 : if (!arg2) {
6296 : {
6297 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6298 : };
6299 : }
6300 : }
6301 0 : result = (char *)wrapper_VSIGetCredential((char const *)arg1,(char const *)arg2,(char const *)arg3);
6302 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6303 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6304 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6305 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
6306 0 : return jresult;
6307 : }
6308 :
6309 :
6310 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetCredential_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
6311 0 : jstring jresult = 0 ;
6312 0 : char *arg1 = (char *) 0 ;
6313 0 : char *arg2 = (char *) 0 ;
6314 0 : char *result = 0 ;
6315 :
6316 : (void)jenv;
6317 : (void)jcls;
6318 0 : arg1 = 0;
6319 0 : if (jarg1) {
6320 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6321 0 : if (!arg1) return 0;
6322 : }
6323 0 : arg2 = 0;
6324 0 : if (jarg2) {
6325 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6326 0 : if (!arg2) return 0;
6327 : }
6328 : {
6329 0 : if (!arg1) {
6330 : {
6331 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6332 : };
6333 : }
6334 : }
6335 : {
6336 0 : if (!arg2) {
6337 : {
6338 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6339 : };
6340 : }
6341 : }
6342 0 : result = (char *)wrapper_VSIGetCredential((char const *)arg1,(char const *)arg2);
6343 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6344 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6345 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6346 0 : return jresult;
6347 : }
6348 :
6349 :
6350 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetPathSpecificOption_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {
6351 0 : jstring jresult = 0 ;
6352 0 : char *arg1 = (char *) 0 ;
6353 0 : char *arg2 = (char *) 0 ;
6354 0 : char *arg3 = (char *) 0 ;
6355 0 : char *result = 0 ;
6356 :
6357 : (void)jenv;
6358 : (void)jcls;
6359 0 : arg1 = 0;
6360 0 : if (jarg1) {
6361 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6362 0 : if (!arg1) return 0;
6363 : }
6364 0 : arg2 = 0;
6365 0 : if (jarg2) {
6366 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6367 0 : if (!arg2) return 0;
6368 : }
6369 0 : arg3 = 0;
6370 0 : if (jarg3) {
6371 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
6372 0 : if (!arg3) return 0;
6373 : }
6374 : {
6375 0 : if (!arg1) {
6376 : {
6377 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6378 : };
6379 : }
6380 : }
6381 : {
6382 0 : if (!arg2) {
6383 : {
6384 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6385 : };
6386 : }
6387 : }
6388 0 : result = (char *)wrapper_VSIGetPathSpecificOption((char const *)arg1,(char const *)arg2,(char const *)arg3);
6389 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6390 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6391 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6392 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
6393 0 : return jresult;
6394 : }
6395 :
6396 :
6397 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetPathSpecificOption_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
6398 0 : jstring jresult = 0 ;
6399 0 : char *arg1 = (char *) 0 ;
6400 0 : char *arg2 = (char *) 0 ;
6401 0 : char *result = 0 ;
6402 :
6403 : (void)jenv;
6404 : (void)jcls;
6405 0 : arg1 = 0;
6406 0 : if (jarg1) {
6407 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6408 0 : if (!arg1) return 0;
6409 : }
6410 0 : arg2 = 0;
6411 0 : if (jarg2) {
6412 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6413 0 : if (!arg2) return 0;
6414 : }
6415 : {
6416 0 : if (!arg1) {
6417 : {
6418 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6419 : };
6420 : }
6421 : }
6422 : {
6423 0 : if (!arg2) {
6424 : {
6425 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6426 : };
6427 : }
6428 : }
6429 0 : result = (char *)wrapper_VSIGetPathSpecificOption((char const *)arg1,(char const *)arg2);
6430 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
6431 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6432 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6433 0 : return jresult;
6434 : }
6435 :
6436 :
6437 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ClearCredentials_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6438 0 : char *arg1 = (char *) 0 ;
6439 :
6440 : (void)jenv;
6441 : (void)jcls;
6442 0 : arg1 = 0;
6443 0 : if (jarg1) {
6444 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6445 0 : if (!arg1) return ;
6446 : }
6447 0 : wrapper_VSIClearCredentials((char const *)arg1);
6448 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6449 : }
6450 :
6451 :
6452 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ClearCredentials_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
6453 : (void)jenv;
6454 : (void)jcls;
6455 0 : wrapper_VSIClearCredentials();
6456 0 : }
6457 :
6458 :
6459 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ClearPathSpecificOptions_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6460 0 : char *arg1 = (char *) 0 ;
6461 :
6462 : (void)jenv;
6463 : (void)jcls;
6464 0 : arg1 = 0;
6465 0 : if (jarg1) {
6466 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6467 0 : if (!arg1) return ;
6468 : }
6469 0 : wrapper_VSIClearPathSpecificOptions((char const *)arg1);
6470 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6471 : }
6472 :
6473 :
6474 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ClearPathSpecificOptions_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
6475 : (void)jenv;
6476 : (void)jcls;
6477 0 : wrapper_VSIClearPathSpecificOptions();
6478 0 : }
6479 :
6480 :
6481 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_CPLBinaryToHex(JNIEnv *jenv, jclass jcls, jbyteArray jarg1) {
6482 0 : jstring jresult = 0 ;
6483 : int arg1 ;
6484 0 : GByte *arg2 = (GByte *) 0 ;
6485 0 : retStringAndCPLFree *result = 0 ;
6486 :
6487 : (void)jenv;
6488 : (void)jcls;
6489 : {
6490 : /* %typemap(in) (int nLen, unsigned char *pBuf ) */
6491 0 : arg1 = 0;
6492 0 : arg2 = NULL;
6493 0 : if (jarg1)
6494 : {
6495 0 : arg1 = jenv->GetArrayLength(jarg1);
6496 0 : arg2 = (unsigned char *)jenv->GetByteArrayElements(jarg1, NULL);
6497 : }
6498 : }
6499 0 : result = (retStringAndCPLFree *)CPLBinaryToHex(arg1,(GByte const *)arg2);
6500 : {
6501 : /* %typemap(out) (retStringAndCPLFree*) */
6502 0 : if(result)
6503 : {
6504 0 : jresult = jenv->NewStringUTF((const char *)result);
6505 0 : CPLFree(result);
6506 : }
6507 : }
6508 : {
6509 : /* %typemap(argout) (int nLen, unsigned char *pBuf ) */
6510 : }
6511 : {
6512 : /* %typemap(freearg) (int nLen, unsigned char *pBuf ) */
6513 : /* This calls JNI_ABORT, so any modifications will not be passed back
6514 : into the Java caller
6515 : */
6516 0 : if(arg2) {
6517 0 : jenv->ReleaseByteArrayElements(jarg1, (jbyte *)arg2, JNI_ABORT);
6518 : }
6519 : }
6520 0 : return jresult;
6521 : }
6522 :
6523 :
6524 0 : SWIGEXPORT jbyteArray JNICALL Java_org_gdal_gdal_gdalJNI_CPLHexToBinary(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6525 0 : jbyteArray jresult = 0 ;
6526 0 : char *arg1 = (char *) 0 ;
6527 0 : int *arg2 = (int *) 0 ;
6528 : int nBytes1 ;
6529 0 : GByte *result = 0 ;
6530 :
6531 : (void)jenv;
6532 : (void)jcls;
6533 : {
6534 : /* %typemap(in) (const char *pszHex, int *pnBytes) */
6535 0 : if (jarg1)
6536 : {
6537 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6538 : }
6539 : else
6540 : {
6541 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6542 : }
6543 0 : arg2 = &nBytes1;
6544 : }
6545 0 : result = (GByte *)CPLHexToBinary((char const *)arg1,arg2);
6546 : {
6547 : /* %typemap(out) (GByte* outBytes ) */
6548 : }
6549 : {
6550 : /* %typemap(argout) (const char *pszHex, int *pnBytes) */
6551 0 : if (jarg1)
6552 : {
6553 0 : jenv->ReleaseStringUTFChars(jarg1, (char*)arg1);
6554 : }
6555 0 : jresult = jenv->NewByteArray(nBytes1);
6556 0 : jenv->SetByteArrayRegion(jresult, (jsize)0, (jsize)nBytes1, (jbyte*)result);
6557 0 : CPLFree(result);
6558 : }
6559 0 : return jresult;
6560 : }
6561 :
6562 :
6563 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FileFromMemBuffer(JNIEnv *jenv, jclass jcls, jstring jarg1, jbyteArray jarg2) {
6564 0 : jint jresult = 0 ;
6565 0 : char *arg1 = (char *) 0 ;
6566 : int arg2 ;
6567 0 : GByte *arg3 = (GByte *) 0 ;
6568 : VSI_RETVAL result;
6569 :
6570 : (void)jenv;
6571 : (void)jcls;
6572 0 : arg1 = 0;
6573 0 : if (jarg1) {
6574 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6575 0 : if (!arg1) return 0;
6576 : }
6577 : {
6578 : /* %typemap(in) (int nLen, unsigned char *pBuf ) */
6579 0 : arg2 = 0;
6580 0 : arg3 = NULL;
6581 0 : if (jarg2)
6582 : {
6583 0 : arg2 = jenv->GetArrayLength(jarg2);
6584 0 : arg3 = (unsigned char *)jenv->GetByteArrayElements(jarg2, NULL);
6585 : }
6586 : }
6587 : {
6588 0 : if (!arg1) {
6589 : {
6590 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6591 : };
6592 : }
6593 : }
6594 0 : result = wrapper_VSIFileFromMemBuffer((char const *)arg1,arg2,(GByte const *)arg3);
6595 0 : jresult = (jint)result;
6596 : {
6597 : /* %typemap(argout) (int nLen, unsigned char *pBuf ) */
6598 : }
6599 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6600 : {
6601 : /* %typemap(freearg) (int nLen, unsigned char *pBuf ) */
6602 : /* This calls JNI_ABORT, so any modifications will not be passed back
6603 : into the Java caller
6604 : */
6605 0 : if(arg3) {
6606 0 : jenv->ReleaseByteArrayElements(jarg2, (jbyte *)arg3, JNI_ABORT);
6607 : }
6608 : }
6609 0 : return jresult;
6610 : }
6611 :
6612 :
6613 2 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Unlink(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6614 2 : jint jresult = 0 ;
6615 2 : char *arg1 = (char *) 0 ;
6616 : VSI_RETVAL result;
6617 :
6618 : (void)jenv;
6619 : (void)jcls;
6620 2 : arg1 = 0;
6621 2 : if (jarg1) {
6622 2 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6623 2 : if (!arg1) return 0;
6624 : }
6625 : {
6626 2 : if (!arg1) {
6627 : {
6628 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6629 : };
6630 : }
6631 : }
6632 2 : result = VSIUnlink((char const *)arg1);
6633 2 : jresult = (jint)result;
6634 2 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6635 2 : return jresult;
6636 : }
6637 :
6638 :
6639 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_UnlinkBatch(JNIEnv *jenv, jclass jcls, jobject jarg1) {
6640 0 : jboolean jresult = 0 ;
6641 0 : char **arg1 = (char **) 0 ;
6642 : bool result;
6643 :
6644 : (void)jenv;
6645 : (void)jcls;
6646 : {
6647 : /* %typemap(in) char **options */
6648 0 : arg1 = NULL;
6649 0 : if(jarg1 != 0) {
6650 0 : const jclass vector = jenv->FindClass("java/util/Vector");
6651 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
6652 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
6653 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
6654 : "()Ljava/util/Enumeration;");
6655 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
6656 : "hasMoreElements", "()Z");
6657 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
6658 : "nextElement", "()Ljava/lang/Object;");
6659 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
6660 0 : hasMoreElements == NULL || getNextElement == NULL) {
6661 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
6662 0 : return 0;
6663 : }
6664 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
6665 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
6666 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
6667 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
6668 : {
6669 0 : CSLDestroy(arg1);
6670 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
6671 0 : return 0;
6672 : }
6673 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
6674 0 : arg1 = CSLAddString(arg1, valptr);
6675 0 : jenv->ReleaseStringUTFChars(value, valptr);
6676 : }
6677 : }
6678 : }
6679 0 : result = (bool)wrapper_VSIUnlinkBatch(arg1);
6680 0 : jresult = (jboolean)result;
6681 : {
6682 : /* %typemap(freearg) char **options */
6683 0 : CSLDestroy( arg1 );
6684 : }
6685 0 : return jresult;
6686 : }
6687 :
6688 :
6689 17 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_HasThreadSupport(JNIEnv *jenv, jclass jcls) {
6690 17 : jint jresult = 0 ;
6691 : int result;
6692 :
6693 : (void)jenv;
6694 : (void)jcls;
6695 17 : result = (int)wrapper_HasThreadSupport();
6696 17 : jresult = (jint)result;
6697 17 : return jresult;
6698 : }
6699 :
6700 :
6701 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Mkdir(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
6702 0 : jint jresult = 0 ;
6703 0 : char *arg1 = (char *) 0 ;
6704 : int arg2 ;
6705 : VSI_RETVAL result;
6706 :
6707 : (void)jenv;
6708 : (void)jcls;
6709 0 : arg1 = 0;
6710 0 : if (jarg1) {
6711 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6712 0 : if (!arg1) return 0;
6713 : }
6714 0 : arg2 = (int)jarg2;
6715 : {
6716 0 : if (!arg1) {
6717 : {
6718 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6719 : };
6720 : }
6721 : }
6722 0 : result = VSIMkdir((char const *)arg1,arg2);
6723 0 : jresult = (jint)result;
6724 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6725 0 : return jresult;
6726 : }
6727 :
6728 :
6729 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Rmdir(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6730 0 : jint jresult = 0 ;
6731 0 : char *arg1 = (char *) 0 ;
6732 : VSI_RETVAL result;
6733 :
6734 : (void)jenv;
6735 : (void)jcls;
6736 0 : arg1 = 0;
6737 0 : if (jarg1) {
6738 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6739 0 : if (!arg1) return 0;
6740 : }
6741 : {
6742 0 : if (!arg1) {
6743 : {
6744 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6745 : };
6746 : }
6747 : }
6748 0 : result = VSIRmdir((char const *)arg1);
6749 0 : jresult = (jint)result;
6750 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6751 0 : return jresult;
6752 : }
6753 :
6754 :
6755 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MkdirRecursive(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
6756 0 : jint jresult = 0 ;
6757 0 : char *arg1 = (char *) 0 ;
6758 : int arg2 ;
6759 : VSI_RETVAL result;
6760 :
6761 : (void)jenv;
6762 : (void)jcls;
6763 0 : arg1 = 0;
6764 0 : if (jarg1) {
6765 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6766 0 : if (!arg1) return 0;
6767 : }
6768 0 : arg2 = (int)jarg2;
6769 : {
6770 0 : if (!arg1) {
6771 : {
6772 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6773 : };
6774 : }
6775 : }
6776 0 : result = VSIMkdirRecursive((char const *)arg1,arg2);
6777 0 : jresult = (jint)result;
6778 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6779 0 : return jresult;
6780 : }
6781 :
6782 :
6783 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RmdirRecursive(JNIEnv *jenv, jclass jcls, jstring jarg1) {
6784 0 : jint jresult = 0 ;
6785 0 : char *arg1 = (char *) 0 ;
6786 : VSI_RETVAL result;
6787 :
6788 : (void)jenv;
6789 : (void)jcls;
6790 0 : arg1 = 0;
6791 0 : if (jarg1) {
6792 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6793 0 : if (!arg1) return 0;
6794 : }
6795 : {
6796 0 : if (!arg1) {
6797 : {
6798 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6799 : };
6800 : }
6801 : }
6802 0 : result = VSIRmdirRecursive((char const *)arg1);
6803 0 : jresult = (jint)result;
6804 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6805 0 : return jresult;
6806 : }
6807 :
6808 :
6809 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Rename(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
6810 0 : jint jresult = 0 ;
6811 0 : char *arg1 = (char *) 0 ;
6812 0 : char *arg2 = (char *) 0 ;
6813 : VSI_RETVAL result;
6814 :
6815 : (void)jenv;
6816 : (void)jcls;
6817 0 : arg1 = 0;
6818 0 : if (jarg1) {
6819 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6820 0 : if (!arg1) return 0;
6821 : }
6822 0 : arg2 = 0;
6823 0 : if (jarg2) {
6824 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6825 0 : if (!arg2) return 0;
6826 : }
6827 : {
6828 0 : if (!arg1) {
6829 : {
6830 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6831 : };
6832 : }
6833 : }
6834 : {
6835 0 : if (!arg2) {
6836 : {
6837 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6838 : };
6839 : }
6840 : }
6841 0 : result = VSIRename((char const *)arg1,(char const *)arg2);
6842 0 : jresult = (jint)result;
6843 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6844 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6845 0 : return jresult;
6846 : }
6847 :
6848 :
6849 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CopyFile_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg5, jobject jarg6) {
6850 0 : jint jresult = 0 ;
6851 0 : char *arg1 = (char *) 0 ;
6852 0 : char *arg2 = (char *) 0 ;
6853 0 : VSILFILE *arg3 = (VSILFILE *) 0 ;
6854 : GIntBig arg4 ;
6855 0 : char **arg5 = (char **) 0 ;
6856 : GDALProgressFunc arg6 ;
6857 0 : void *arg7 = (void *) 0 ;
6858 : int result;
6859 :
6860 : (void)jenv;
6861 : (void)jcls;
6862 : JavaProgressData sProgressInfo;
6863 0 : sProgressInfo.jenv = jenv;
6864 0 : sProgressInfo.pJavaCallback = NULL;
6865 0 : arg1 = 0;
6866 0 : if (jarg1) {
6867 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6868 0 : if (!arg1) return 0;
6869 : }
6870 0 : arg2 = 0;
6871 0 : if (jarg2) {
6872 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6873 0 : if (!arg2) return 0;
6874 : }
6875 0 : arg3 = *(VSILFILE **)&jarg3;
6876 : {
6877 : /* %typemap(in) (GIntBig) */
6878 0 : arg4 = (GIntBig) jarg4;
6879 : }
6880 : {
6881 : /* %typemap(in) char **options */
6882 0 : arg5 = NULL;
6883 0 : if(jarg5 != 0) {
6884 0 : const jclass vector = jenv->FindClass("java/util/Vector");
6885 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
6886 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
6887 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
6888 : "()Ljava/util/Enumeration;");
6889 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
6890 : "hasMoreElements", "()Z");
6891 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
6892 : "nextElement", "()Ljava/lang/Object;");
6893 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
6894 0 : hasMoreElements == NULL || getNextElement == NULL) {
6895 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
6896 0 : return 0;
6897 : }
6898 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
6899 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
6900 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
6901 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
6902 : {
6903 0 : CSLDestroy(arg5);
6904 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
6905 0 : return 0;
6906 : }
6907 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
6908 0 : arg5 = CSLAddString(arg5, valptr);
6909 0 : jenv->ReleaseStringUTFChars(value, valptr);
6910 : }
6911 : }
6912 : }
6913 : {
6914 0 : if ( jarg6 != 0 ) {
6915 0 : sProgressInfo.pJavaCallback = jarg6;
6916 0 : arg6 = JavaProgressProxy;
6917 0 : arg7 = &sProgressInfo;
6918 : }
6919 : else
6920 : {
6921 0 : arg6 = NULL;
6922 0 : arg7 = NULL;
6923 : }
6924 : }
6925 : {
6926 0 : if (!arg1) {
6927 : {
6928 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6929 : };
6930 : }
6931 : }
6932 : {
6933 0 : if (!arg2) {
6934 : {
6935 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
6936 : };
6937 : }
6938 : }
6939 0 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
6940 0 : jresult = (jint)result;
6941 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
6942 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
6943 : {
6944 : /* %typemap(freearg) char **options */
6945 0 : CSLDestroy( arg5 );
6946 : }
6947 0 : return jresult;
6948 : }
6949 :
6950 :
6951 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CopyFile_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg5) {
6952 0 : jint jresult = 0 ;
6953 0 : char *arg1 = (char *) 0 ;
6954 0 : char *arg2 = (char *) 0 ;
6955 0 : VSILFILE *arg3 = (VSILFILE *) 0 ;
6956 : GIntBig arg4 ;
6957 0 : char **arg5 = (char **) 0 ;
6958 : int result;
6959 :
6960 : (void)jenv;
6961 : (void)jcls;
6962 0 : arg1 = 0;
6963 0 : if (jarg1) {
6964 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
6965 0 : if (!arg1) return 0;
6966 : }
6967 0 : arg2 = 0;
6968 0 : if (jarg2) {
6969 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
6970 0 : if (!arg2) return 0;
6971 : }
6972 0 : arg3 = *(VSILFILE **)&jarg3;
6973 : {
6974 : /* %typemap(in) (GIntBig) */
6975 0 : arg4 = (GIntBig) jarg4;
6976 : }
6977 : {
6978 : /* %typemap(in) char **options */
6979 0 : arg5 = NULL;
6980 0 : if(jarg5 != 0) {
6981 0 : const jclass vector = jenv->FindClass("java/util/Vector");
6982 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
6983 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
6984 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
6985 : "()Ljava/util/Enumeration;");
6986 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
6987 : "hasMoreElements", "()Z");
6988 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
6989 : "nextElement", "()Ljava/lang/Object;");
6990 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
6991 0 : hasMoreElements == NULL || getNextElement == NULL) {
6992 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
6993 0 : return 0;
6994 : }
6995 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
6996 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
6997 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
6998 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
6999 : {
7000 0 : CSLDestroy(arg5);
7001 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
7002 0 : return 0;
7003 : }
7004 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
7005 0 : arg5 = CSLAddString(arg5, valptr);
7006 0 : jenv->ReleaseStringUTFChars(value, valptr);
7007 : }
7008 : }
7009 : }
7010 : {
7011 0 : if (!arg1) {
7012 : {
7013 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7014 : };
7015 : }
7016 : }
7017 : {
7018 0 : if (!arg2) {
7019 : {
7020 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7021 : };
7022 : }
7023 : }
7024 0 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2,arg3,arg4,arg5);
7025 0 : jresult = (jint)result;
7026 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7027 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7028 : {
7029 : /* %typemap(freearg) char **options */
7030 0 : CSLDestroy( arg5 );
7031 : }
7032 0 : return jresult;
7033 : }
7034 :
7035 :
7036 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CopyFile_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jlong jarg3, jlong jarg4) {
7037 0 : jint jresult = 0 ;
7038 0 : char *arg1 = (char *) 0 ;
7039 0 : char *arg2 = (char *) 0 ;
7040 0 : VSILFILE *arg3 = (VSILFILE *) 0 ;
7041 : GIntBig arg4 ;
7042 : int result;
7043 :
7044 : (void)jenv;
7045 : (void)jcls;
7046 0 : arg1 = 0;
7047 0 : if (jarg1) {
7048 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7049 0 : if (!arg1) return 0;
7050 : }
7051 0 : arg2 = 0;
7052 0 : if (jarg2) {
7053 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7054 0 : if (!arg2) return 0;
7055 : }
7056 0 : arg3 = *(VSILFILE **)&jarg3;
7057 : {
7058 : /* %typemap(in) (GIntBig) */
7059 0 : arg4 = (GIntBig) jarg4;
7060 : }
7061 : {
7062 0 : if (!arg1) {
7063 : {
7064 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7065 : };
7066 : }
7067 : }
7068 : {
7069 0 : if (!arg2) {
7070 : {
7071 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7072 : };
7073 : }
7074 : }
7075 0 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2,arg3,arg4);
7076 0 : jresult = (jint)result;
7077 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7078 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7079 0 : return jresult;
7080 : }
7081 :
7082 :
7083 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CopyFile_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jlong jarg3) {
7084 0 : jint jresult = 0 ;
7085 0 : char *arg1 = (char *) 0 ;
7086 0 : char *arg2 = (char *) 0 ;
7087 0 : VSILFILE *arg3 = (VSILFILE *) 0 ;
7088 : int result;
7089 :
7090 : (void)jenv;
7091 : (void)jcls;
7092 0 : arg1 = 0;
7093 0 : if (jarg1) {
7094 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7095 0 : if (!arg1) return 0;
7096 : }
7097 0 : arg2 = 0;
7098 0 : if (jarg2) {
7099 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7100 0 : if (!arg2) return 0;
7101 : }
7102 0 : arg3 = *(VSILFILE **)&jarg3;
7103 : {
7104 0 : if (!arg1) {
7105 : {
7106 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7107 : };
7108 : }
7109 : }
7110 : {
7111 0 : if (!arg2) {
7112 : {
7113 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7114 : };
7115 : }
7116 : }
7117 0 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2,arg3);
7118 0 : jresult = (jint)result;
7119 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7120 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7121 0 : return jresult;
7122 : }
7123 :
7124 :
7125 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CopyFile_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
7126 0 : jint jresult = 0 ;
7127 0 : char *arg1 = (char *) 0 ;
7128 0 : char *arg2 = (char *) 0 ;
7129 : int result;
7130 :
7131 : (void)jenv;
7132 : (void)jcls;
7133 0 : arg1 = 0;
7134 0 : if (jarg1) {
7135 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7136 0 : if (!arg1) return 0;
7137 : }
7138 0 : arg2 = 0;
7139 0 : if (jarg2) {
7140 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7141 0 : if (!arg2) return 0;
7142 : }
7143 : {
7144 0 : if (!arg1) {
7145 : {
7146 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7147 : };
7148 : }
7149 : }
7150 : {
7151 0 : if (!arg2) {
7152 : {
7153 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7154 : };
7155 : }
7156 : }
7157 0 : result = (int)wrapper_VSICopyFile((char const *)arg1,(char const *)arg2);
7158 0 : jresult = (jint)result;
7159 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7160 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7161 0 : return jresult;
7162 : }
7163 :
7164 :
7165 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetActualURL(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7166 0 : jstring jresult = 0 ;
7167 0 : char *arg1 = (char *) 0 ;
7168 0 : char *result = 0 ;
7169 :
7170 : (void)jenv;
7171 : (void)jcls;
7172 0 : arg1 = 0;
7173 0 : if (jarg1) {
7174 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7175 0 : if (!arg1) return 0;
7176 : }
7177 : {
7178 0 : if (!arg1) {
7179 : {
7180 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7181 : };
7182 : }
7183 : }
7184 0 : result = (char *)VSIGetActualURL((char const *)arg1);
7185 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
7186 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7187 0 : return jresult;
7188 : }
7189 :
7190 :
7191 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetSignedURL_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2) {
7192 0 : jstring jresult = 0 ;
7193 0 : char *arg1 = (char *) 0 ;
7194 0 : char **arg2 = (char **) 0 ;
7195 0 : retStringAndCPLFree *result = 0 ;
7196 :
7197 : (void)jenv;
7198 : (void)jcls;
7199 0 : arg1 = 0;
7200 0 : if (jarg1) {
7201 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7202 0 : if (!arg1) return 0;
7203 : }
7204 : {
7205 : /* %typemap(in) char **options */
7206 0 : arg2 = NULL;
7207 0 : if(jarg2 != 0) {
7208 0 : const jclass vector = jenv->FindClass("java/util/Vector");
7209 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
7210 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
7211 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
7212 : "()Ljava/util/Enumeration;");
7213 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
7214 : "hasMoreElements", "()Z");
7215 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
7216 : "nextElement", "()Ljava/lang/Object;");
7217 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
7218 0 : hasMoreElements == NULL || getNextElement == NULL) {
7219 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
7220 0 : return 0;
7221 : }
7222 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
7223 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
7224 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
7225 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
7226 : {
7227 0 : CSLDestroy(arg2);
7228 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
7229 0 : return 0;
7230 : }
7231 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
7232 0 : arg2 = CSLAddString(arg2, valptr);
7233 0 : jenv->ReleaseStringUTFChars(value, valptr);
7234 : }
7235 : }
7236 : }
7237 : {
7238 0 : if (!arg1) {
7239 : {
7240 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7241 : };
7242 : }
7243 : }
7244 0 : result = (retStringAndCPLFree *)wrapper_VSIGetSignedURL((char const *)arg1,arg2);
7245 : {
7246 : /* %typemap(out) (retStringAndCPLFree*) */
7247 0 : if(result)
7248 : {
7249 0 : jresult = jenv->NewStringUTF((const char *)result);
7250 0 : CPLFree(result);
7251 : }
7252 : }
7253 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7254 : {
7255 : /* %typemap(freearg) char **options */
7256 0 : CSLDestroy( arg2 );
7257 : }
7258 0 : return jresult;
7259 : }
7260 :
7261 :
7262 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetSignedURL_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7263 0 : jstring jresult = 0 ;
7264 0 : char *arg1 = (char *) 0 ;
7265 0 : retStringAndCPLFree *result = 0 ;
7266 :
7267 : (void)jenv;
7268 : (void)jcls;
7269 0 : arg1 = 0;
7270 0 : if (jarg1) {
7271 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7272 0 : if (!arg1) return 0;
7273 : }
7274 : {
7275 0 : if (!arg1) {
7276 : {
7277 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7278 : };
7279 : }
7280 : }
7281 0 : result = (retStringAndCPLFree *)wrapper_VSIGetSignedURL((char const *)arg1);
7282 : {
7283 : /* %typemap(out) (retStringAndCPLFree*) */
7284 0 : if(result)
7285 : {
7286 0 : jresult = jenv->NewStringUTF((const char *)result);
7287 0 : CPLFree(result);
7288 : }
7289 : }
7290 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7291 0 : return jresult;
7292 : }
7293 :
7294 :
7295 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_GetFileSystemsPrefixes(JNIEnv *jenv, jclass jcls) {
7296 0 : jobject jresult = 0 ;
7297 0 : char **result = 0 ;
7298 :
7299 : (void)jenv;
7300 : (void)jcls;
7301 0 : result = (char **)VSIGetFileSystemsPrefixes();
7302 : {
7303 : /* %typemap(out) char **CSL */
7304 0 : char **stringarray = result;
7305 0 : const jclass vector = jenv->FindClass("java/util/Vector");
7306 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
7307 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
7308 :
7309 0 : jresult = jenv->NewObject(vector, constructor);
7310 0 : if ( stringarray != NULL ) {
7311 0 : while(*stringarray != NULL) {
7312 : /*printf("working on string %s\n", *stringarray);*/
7313 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
7314 0 : jenv->CallBooleanMethod(jresult, add, value);
7315 0 : jenv->DeleteLocalRef(value);
7316 0 : stringarray++;
7317 : }
7318 : }
7319 0 : CSLDestroy(result);
7320 : }
7321 0 : return jresult;
7322 : }
7323 :
7324 :
7325 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetFileSystemOptions(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7326 0 : jstring jresult = 0 ;
7327 0 : char *arg1 = (char *) 0 ;
7328 0 : char *result = 0 ;
7329 :
7330 : (void)jenv;
7331 : (void)jcls;
7332 0 : arg1 = 0;
7333 0 : if (jarg1) {
7334 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7335 0 : if (!arg1) return 0;
7336 : }
7337 : {
7338 0 : if (!arg1) {
7339 : {
7340 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7341 : };
7342 : }
7343 : }
7344 0 : result = (char *)VSIGetFileSystemOptions((char const *)arg1);
7345 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
7346 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7347 0 : return jresult;
7348 : }
7349 :
7350 :
7351 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_ParseCommandLine(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7352 0 : jobject jresult = 0 ;
7353 0 : char *arg1 = (char *) 0 ;
7354 0 : char **result = 0 ;
7355 :
7356 : (void)jenv;
7357 : (void)jcls;
7358 0 : arg1 = 0;
7359 0 : if (jarg1) {
7360 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7361 0 : if (!arg1) return 0;
7362 : }
7363 : {
7364 0 : if (!arg1) {
7365 : {
7366 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7367 : };
7368 : }
7369 : }
7370 0 : result = (char **)CSLParseCommandLine((char const *)arg1);
7371 : {
7372 : /* %typemap(out) char **CSL */
7373 0 : char **stringarray = result;
7374 0 : const jclass vector = jenv->FindClass("java/util/Vector");
7375 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
7376 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
7377 :
7378 0 : jresult = jenv->NewObject(vector, constructor);
7379 0 : if ( stringarray != NULL ) {
7380 0 : while(*stringarray != NULL) {
7381 : /*printf("working on string %s\n", *stringarray);*/
7382 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
7383 0 : jenv->CallBooleanMethod(jresult, add, value);
7384 0 : jenv->DeleteLocalRef(value);
7385 0 : stringarray++;
7386 : }
7387 : }
7388 0 : CSLDestroy(result);
7389 : }
7390 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7391 0 : return jresult;
7392 : }
7393 :
7394 :
7395 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetNumCPUs(JNIEnv *jenv, jclass jcls) {
7396 0 : jint jresult = 0 ;
7397 : int result;
7398 :
7399 : (void)jenv;
7400 : (void)jcls;
7401 0 : result = (int)CPLGetNumCPUs();
7402 0 : jresult = (jint)result;
7403 0 : return jresult;
7404 : }
7405 :
7406 :
7407 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_GetUsablePhysicalRAM(JNIEnv *jenv, jclass jcls) {
7408 0 : jlong jresult = 0 ;
7409 : GIntBig result;
7410 :
7411 : (void)jenv;
7412 : (void)jcls;
7413 0 : result = CPLGetUsablePhysicalRAM();
7414 : {
7415 : /* %typemap(out) (GIntBig) */
7416 0 : jresult = (jlong) result;
7417 : }
7418 0 : return jresult;
7419 : }
7420 :
7421 :
7422 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CXT_1Element_1get(JNIEnv *jenv, jclass jcls) {
7423 0 : jint jresult = 0 ;
7424 : CPLXMLNodeType result;
7425 :
7426 : (void)jenv;
7427 : (void)jcls;
7428 0 : result = (CPLXMLNodeType)CXT_Element;
7429 0 : jresult = (jint)result;
7430 0 : return jresult;
7431 : }
7432 :
7433 :
7434 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CXT_1Text_1get(JNIEnv *jenv, jclass jcls) {
7435 0 : jint jresult = 0 ;
7436 : CPLXMLNodeType result;
7437 :
7438 : (void)jenv;
7439 : (void)jcls;
7440 0 : result = (CPLXMLNodeType)CXT_Text;
7441 0 : jresult = (jint)result;
7442 0 : return jresult;
7443 : }
7444 :
7445 :
7446 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CXT_1Attribute_1get(JNIEnv *jenv, jclass jcls) {
7447 0 : jint jresult = 0 ;
7448 : CPLXMLNodeType result;
7449 :
7450 : (void)jenv;
7451 : (void)jcls;
7452 0 : result = (CPLXMLNodeType)CXT_Attribute;
7453 0 : jresult = (jint)result;
7454 0 : return jresult;
7455 : }
7456 :
7457 :
7458 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CXT_1Comment_1get(JNIEnv *jenv, jclass jcls) {
7459 0 : jint jresult = 0 ;
7460 : CPLXMLNodeType result;
7461 :
7462 : (void)jenv;
7463 : (void)jcls;
7464 0 : result = (CPLXMLNodeType)CXT_Comment;
7465 0 : jresult = (jint)result;
7466 0 : return jresult;
7467 : }
7468 :
7469 :
7470 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_CXT_1Literal_1get(JNIEnv *jenv, jclass jcls) {
7471 0 : jint jresult = 0 ;
7472 : CPLXMLNodeType result;
7473 :
7474 : (void)jenv;
7475 : (void)jcls;
7476 0 : result = (CPLXMLNodeType)CXT_Literal;
7477 0 : jresult = (jint)result;
7478 0 : return jresult;
7479 : }
7480 :
7481 :
7482 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1Type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7483 0 : jint jresult = 0 ;
7484 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7485 : CPLXMLNodeType result;
7486 :
7487 : (void)jenv;
7488 : (void)jcls;
7489 : (void)jarg1_;
7490 0 : arg1 = *(CPLXMLNode **)&jarg1;
7491 0 : result = (CPLXMLNodeType) ((arg1)->eType);
7492 0 : jresult = (jint)result;
7493 0 : return jresult;
7494 : }
7495 :
7496 :
7497 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1Value_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7498 0 : jstring jresult = 0 ;
7499 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7500 0 : char *result = 0 ;
7501 :
7502 : (void)jenv;
7503 : (void)jcls;
7504 : (void)jarg1_;
7505 0 : arg1 = *(CPLXMLNode **)&jarg1;
7506 0 : result = (char *) ((arg1)->pszValue);
7507 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
7508 0 : return jresult;
7509 : }
7510 :
7511 :
7512 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1Next_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7513 0 : jlong jresult = 0 ;
7514 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7515 0 : CPLXMLNode *result = 0 ;
7516 :
7517 : (void)jenv;
7518 : (void)jcls;
7519 : (void)jarg1_;
7520 0 : arg1 = *(CPLXMLNode **)&jarg1;
7521 0 : result = (CPLXMLNode *) ((arg1)->psNext);
7522 0 : *(CPLXMLNode **)&jresult = result;
7523 0 : return jresult;
7524 : }
7525 :
7526 :
7527 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1Child_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7528 0 : jlong jresult = 0 ;
7529 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7530 0 : CPLXMLNode *result = 0 ;
7531 :
7532 : (void)jenv;
7533 : (void)jcls;
7534 : (void)jarg1_;
7535 0 : arg1 = *(CPLXMLNode **)&jarg1;
7536 0 : result = (CPLXMLNode *) ((arg1)->psChild);
7537 0 : *(CPLXMLNode **)&jresult = result;
7538 0 : return jresult;
7539 : }
7540 :
7541 :
7542 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1XMLNode_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7543 0 : jlong jresult = 0 ;
7544 0 : char *arg1 = (char *) 0 ;
7545 0 : CPLXMLNode *result = 0 ;
7546 :
7547 : (void)jenv;
7548 : (void)jcls;
7549 0 : arg1 = 0;
7550 0 : if (jarg1) {
7551 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7552 0 : if (!arg1) return 0;
7553 : }
7554 0 : result = (CPLXMLNode *)new_CPLXMLNode__SWIG_0((char const *)arg1);
7555 0 : *(CPLXMLNode **)&jresult = result;
7556 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7557 0 : return jresult;
7558 : }
7559 :
7560 :
7561 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1XMLNode_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jstring jarg2) {
7562 0 : jlong jresult = 0 ;
7563 : CPLXMLNodeType arg1 ;
7564 0 : char *arg2 = (char *) 0 ;
7565 0 : CPLXMLNode *result = 0 ;
7566 :
7567 : (void)jenv;
7568 : (void)jcls;
7569 0 : arg1 = (CPLXMLNodeType)jarg1;
7570 0 : arg2 = 0;
7571 0 : if (jarg2) {
7572 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7573 0 : if (!arg2) return 0;
7574 : }
7575 0 : result = (CPLXMLNode *)new_CPLXMLNode__SWIG_1(arg1,(char const *)arg2);
7576 0 : *(CPLXMLNode **)&jresult = result;
7577 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7578 0 : return jresult;
7579 : }
7580 :
7581 :
7582 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1XMLNode(JNIEnv *jenv, jclass jcls, jlong jarg1) {
7583 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7584 :
7585 : (void)jenv;
7586 : (void)jcls;
7587 0 : arg1 = *(CPLXMLNode **)&jarg1;
7588 0 : delete_CPLXMLNode(arg1);
7589 0 : }
7590 :
7591 :
7592 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1ParseXMLFile(JNIEnv *jenv, jclass jcls, jstring jarg1) {
7593 0 : jlong jresult = 0 ;
7594 0 : char *arg1 = (char *) 0 ;
7595 0 : CPLXMLNode *result = 0 ;
7596 :
7597 : (void)jenv;
7598 : (void)jcls;
7599 0 : arg1 = 0;
7600 0 : if (jarg1) {
7601 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
7602 0 : if (!arg1) return 0;
7603 : }
7604 : {
7605 0 : if (!arg1) {
7606 : {
7607 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
7608 : };
7609 : }
7610 : }
7611 0 : result = (CPLXMLNode *)CPLXMLNode_ParseXMLFile((char const *)arg1);
7612 0 : *(CPLXMLNode **)&jresult = result;
7613 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
7614 0 : return jresult;
7615 : }
7616 :
7617 :
7618 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1SerializeXMLTree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7619 0 : jstring jresult = 0 ;
7620 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7621 0 : retStringAndCPLFree *result = 0 ;
7622 :
7623 : (void)jenv;
7624 : (void)jcls;
7625 : (void)jarg1_;
7626 0 : arg1 = *(CPLXMLNode **)&jarg1;
7627 0 : result = (retStringAndCPLFree *)CPLXMLNode_SerializeXMLTree(arg1);
7628 : {
7629 : /* %typemap(out) (retStringAndCPLFree*) */
7630 0 : if(result)
7631 : {
7632 0 : jresult = jenv->NewStringUTF((const char *)result);
7633 0 : CPLFree(result);
7634 : }
7635 : }
7636 0 : return jresult;
7637 : }
7638 :
7639 :
7640 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1toString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7641 0 : jstring jresult = 0 ;
7642 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7643 0 : retStringAndCPLFree *result = 0 ;
7644 :
7645 : (void)jenv;
7646 : (void)jcls;
7647 : (void)jarg1_;
7648 0 : arg1 = *(CPLXMLNode **)&jarg1;
7649 0 : result = (retStringAndCPLFree *)CPLXMLNode_toString(arg1);
7650 : {
7651 : /* %typemap(out) (retStringAndCPLFree*) */
7652 0 : if(result)
7653 : {
7654 0 : jresult = jenv->NewStringUTF((const char *)result);
7655 0 : CPLFree(result);
7656 : }
7657 : }
7658 0 : return jresult;
7659 : }
7660 :
7661 :
7662 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1SearchXMLNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
7663 0 : jlong jresult = 0 ;
7664 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7665 0 : char *arg2 = (char *) 0 ;
7666 0 : CPLXMLNode *result = 0 ;
7667 :
7668 : (void)jenv;
7669 : (void)jcls;
7670 : (void)jarg1_;
7671 0 : arg1 = *(CPLXMLNode **)&jarg1;
7672 0 : arg2 = 0;
7673 0 : if (jarg2) {
7674 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7675 0 : if (!arg2) return 0;
7676 : }
7677 0 : result = (CPLXMLNode *)CPLXMLNode_SearchXMLNode(arg1,(char const *)arg2);
7678 0 : *(CPLXMLNode **)&jresult = result;
7679 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7680 0 : return jresult;
7681 : }
7682 :
7683 :
7684 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1GetXMLNode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
7685 0 : jlong jresult = 0 ;
7686 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7687 0 : char *arg2 = (char *) 0 ;
7688 0 : CPLXMLNode *result = 0 ;
7689 :
7690 : (void)jenv;
7691 : (void)jcls;
7692 : (void)jarg1_;
7693 0 : arg1 = *(CPLXMLNode **)&jarg1;
7694 0 : arg2 = 0;
7695 0 : if (jarg2) {
7696 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7697 0 : if (!arg2) return 0;
7698 : }
7699 0 : result = (CPLXMLNode *)CPLXMLNode_GetXMLNode(arg1,(char const *)arg2);
7700 0 : *(CPLXMLNode **)&jresult = result;
7701 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7702 0 : return jresult;
7703 : }
7704 :
7705 :
7706 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1GetXMLValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
7707 0 : jstring jresult = 0 ;
7708 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7709 0 : char *arg2 = (char *) 0 ;
7710 0 : char *arg3 = (char *) 0 ;
7711 0 : char *result = 0 ;
7712 :
7713 : (void)jenv;
7714 : (void)jcls;
7715 : (void)jarg1_;
7716 0 : arg1 = *(CPLXMLNode **)&jarg1;
7717 0 : arg2 = 0;
7718 0 : if (jarg2) {
7719 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7720 0 : if (!arg2) return 0;
7721 : }
7722 0 : arg3 = 0;
7723 0 : if (jarg3) {
7724 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
7725 0 : if (!arg3) return 0;
7726 : }
7727 0 : result = (char *)CPLXMLNode_GetXMLValue(arg1,(char const *)arg2,(char const *)arg3);
7728 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
7729 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7730 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
7731 0 : return jresult;
7732 : }
7733 :
7734 :
7735 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1AddXMLChild(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
7736 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7737 0 : CPLXMLNode *arg2 = (CPLXMLNode *) 0 ;
7738 :
7739 : (void)jenv;
7740 : (void)jcls;
7741 : (void)jarg1_;
7742 : (void)jarg2_;
7743 0 : arg1 = *(CPLXMLNode **)&jarg1;
7744 0 : arg2 = *(CPLXMLNode **)&jarg2;
7745 : {
7746 0 : if (!arg2) {
7747 : {
7748 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
7749 : };
7750 : }
7751 : }
7752 0 : CPLXMLNode_AddXMLChild(arg1,arg2);
7753 : }
7754 :
7755 :
7756 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1AddXMLSibling(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
7757 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7758 0 : CPLXMLNode *arg2 = (CPLXMLNode *) 0 ;
7759 :
7760 : (void)jenv;
7761 : (void)jcls;
7762 : (void)jarg1_;
7763 : (void)jarg2_;
7764 0 : arg1 = *(CPLXMLNode **)&jarg1;
7765 0 : arg2 = *(CPLXMLNode **)&jarg2;
7766 : {
7767 0 : if (!arg2) {
7768 : {
7769 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
7770 : };
7771 : }
7772 : }
7773 0 : CPLXMLNode_AddXMLSibling(arg1,arg2);
7774 : }
7775 :
7776 :
7777 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1Clone(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7778 0 : jlong jresult = 0 ;
7779 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7780 0 : CPLXMLNode *result = 0 ;
7781 :
7782 : (void)jenv;
7783 : (void)jcls;
7784 : (void)jarg1_;
7785 0 : arg1 = *(CPLXMLNode **)&jarg1;
7786 0 : result = (CPLXMLNode *)CPLXMLNode_Clone(arg1);
7787 0 : *(CPLXMLNode **)&jresult = result;
7788 0 : return jresult;
7789 : }
7790 :
7791 :
7792 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1SetXMLValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
7793 0 : jint jresult = 0 ;
7794 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7795 0 : char *arg2 = (char *) 0 ;
7796 0 : char *arg3 = (char *) 0 ;
7797 : int result;
7798 :
7799 : (void)jenv;
7800 : (void)jcls;
7801 : (void)jarg1_;
7802 0 : arg1 = *(CPLXMLNode **)&jarg1;
7803 0 : arg2 = 0;
7804 0 : if (jarg2) {
7805 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7806 0 : if (!arg2) return 0;
7807 : }
7808 0 : arg3 = 0;
7809 0 : if (jarg3) {
7810 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
7811 0 : if (!arg3) return 0;
7812 : }
7813 0 : result = (int)CPLXMLNode_SetXMLValue(arg1,(char const *)arg2,(char const *)arg3);
7814 0 : jresult = (jint)result;
7815 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7816 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
7817 0 : return jresult;
7818 : }
7819 :
7820 :
7821 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_XMLNode_1StripXMLNamespace(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
7822 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
7823 0 : char *arg2 = (char *) 0 ;
7824 : int arg3 ;
7825 :
7826 : (void)jenv;
7827 : (void)jcls;
7828 : (void)jarg1_;
7829 0 : arg1 = *(CPLXMLNode **)&jarg1;
7830 0 : arg2 = 0;
7831 0 : if (jarg2) {
7832 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7833 0 : if (!arg2) return ;
7834 : }
7835 0 : arg3 = (int)jarg3;
7836 0 : CPLXMLNode_StripXMLNamespace(arg1,(char const *)arg2,arg3);
7837 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7838 : }
7839 :
7840 :
7841 2 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetDescription(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7842 2 : jstring jresult = 0 ;
7843 2 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7844 2 : char *result = 0 ;
7845 :
7846 : (void)jenv;
7847 : (void)jcls;
7848 : (void)jarg1_;
7849 2 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7850 2 : result = (char *)GDALMajorObjectShadow_GetDescription(arg1);
7851 2 : if (result) jresult = jenv->NewStringUTF((const char *)result);
7852 2 : return jresult;
7853 : }
7854 :
7855 :
7856 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetDescription(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
7857 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7858 1 : char *arg2 = (char *) 0 ;
7859 :
7860 : (void)jenv;
7861 : (void)jcls;
7862 : (void)jarg1_;
7863 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7864 1 : arg2 = 0;
7865 1 : if (jarg2) {
7866 1 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7867 1 : if (!arg2) return ;
7868 : }
7869 : {
7870 1 : if (!arg2) {
7871 : {
7872 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
7873 : };
7874 : }
7875 : }
7876 1 : GDALMajorObjectShadow_SetDescription(arg1,(char const *)arg2);
7877 1 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7878 : }
7879 :
7880 :
7881 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadataDomainList(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7882 0 : jobject jresult = 0 ;
7883 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7884 0 : char **result = 0 ;
7885 :
7886 : (void)jenv;
7887 : (void)jcls;
7888 : (void)jarg1_;
7889 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7890 0 : result = (char **)GDALMajorObjectShadow_GetMetadataDomainList(arg1);
7891 : {
7892 : /* %typemap(out) char **CSL */
7893 0 : char **stringarray = result;
7894 0 : const jclass vector = jenv->FindClass("java/util/Vector");
7895 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
7896 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
7897 :
7898 0 : jresult = jenv->NewObject(vector, constructor);
7899 0 : if ( stringarray != NULL ) {
7900 0 : while(*stringarray != NULL) {
7901 : /*printf("working on string %s\n", *stringarray);*/
7902 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
7903 0 : jenv->CallBooleanMethod(jresult, add, value);
7904 0 : jenv->DeleteLocalRef(value);
7905 0 : stringarray++;
7906 : }
7907 : }
7908 0 : CSLDestroy(result);
7909 : }
7910 0 : return jresult;
7911 : }
7912 :
7913 :
7914 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadata_1Dict_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
7915 0 : jobject jresult = 0 ;
7916 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7917 0 : char *arg2 = (char *) 0 ;
7918 0 : char **result = 0 ;
7919 :
7920 : (void)jenv;
7921 : (void)jcls;
7922 : (void)jarg1_;
7923 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7924 0 : arg2 = 0;
7925 0 : if (jarg2) {
7926 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7927 0 : if (!arg2) return 0;
7928 : }
7929 0 : result = (char **)GDALMajorObjectShadow_GetMetadata_Dict__SWIG_0(arg1,(char const *)arg2);
7930 : {
7931 : /* %typemap(out) char **dict */
7932 0 : jresult = GetCSLStringAsHashTable(jenv, result, false);
7933 : }
7934 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7935 0 : return jresult;
7936 : }
7937 :
7938 :
7939 1 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadata_1Dict_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7940 1 : jobject jresult = 0 ;
7941 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7942 1 : char **result = 0 ;
7943 :
7944 : (void)jenv;
7945 : (void)jcls;
7946 : (void)jarg1_;
7947 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7948 1 : result = (char **)GDALMajorObjectShadow_GetMetadata_Dict__SWIG_0(arg1);
7949 : {
7950 : /* %typemap(out) char **dict */
7951 1 : jresult = GetCSLStringAsHashTable(jenv, result, false);
7952 : }
7953 1 : return jresult;
7954 : }
7955 :
7956 :
7957 6 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadata_1List_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
7958 6 : jobject jresult = 0 ;
7959 6 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7960 6 : char *arg2 = (char *) 0 ;
7961 6 : char **result = 0 ;
7962 :
7963 : (void)jenv;
7964 : (void)jcls;
7965 : (void)jarg1_;
7966 6 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
7967 6 : arg2 = 0;
7968 6 : if (jarg2) {
7969 6 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
7970 6 : if (!arg2) return 0;
7971 : }
7972 6 : result = (char **)GDALMajorObjectShadow_GetMetadata_List__SWIG_0(arg1,(char const *)arg2);
7973 : {
7974 : /* %typemap(out) char **options */
7975 6 : char **stringarray = result;
7976 6 : const jclass vector = jenv->FindClass("java/util/Vector");
7977 6 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
7978 6 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
7979 :
7980 6 : jresult = jenv->NewObject(vector, constructor);
7981 6 : if ( stringarray != NULL ) {
7982 4 : while(*stringarray != NULL) {
7983 : /*printf("working on string %s\n", *stringarray);*/
7984 2 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
7985 2 : jenv->CallBooleanMethod(jresult, add, value);
7986 2 : jenv->DeleteLocalRef(value);
7987 2 : stringarray++;
7988 : }
7989 : }
7990 : }
7991 6 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
7992 6 : return jresult;
7993 : }
7994 :
7995 :
7996 1 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadata_1List_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
7997 1 : jobject jresult = 0 ;
7998 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
7999 1 : char **result = 0 ;
8000 :
8001 : (void)jenv;
8002 : (void)jcls;
8003 : (void)jarg1_;
8004 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8005 1 : result = (char **)GDALMajorObjectShadow_GetMetadata_List__SWIG_0(arg1);
8006 : {
8007 : /* %typemap(out) char **options */
8008 1 : char **stringarray = result;
8009 1 : const jclass vector = jenv->FindClass("java/util/Vector");
8010 1 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
8011 1 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
8012 :
8013 1 : jresult = jenv->NewObject(vector, constructor);
8014 1 : if ( stringarray != NULL ) {
8015 2 : while(*stringarray != NULL) {
8016 : /*printf("working on string %s\n", *stringarray);*/
8017 1 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
8018 1 : jenv->CallBooleanMethod(jresult, add, value);
8019 1 : jenv->DeleteLocalRef(value);
8020 1 : stringarray++;
8021 : }
8022 : }
8023 : }
8024 1 : return jresult;
8025 : }
8026 :
8027 :
8028 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadata_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jstring jarg3) {
8029 1 : jint jresult = 0 ;
8030 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8031 1 : char **arg2 = (char **) 0 ;
8032 1 : char *arg3 = (char *) 0 ;
8033 : CPLErr result;
8034 :
8035 : (void)jenv;
8036 : (void)jcls;
8037 : (void)jarg1_;
8038 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8039 : {
8040 : /* %typemap(in) char **options */
8041 1 : arg2 = NULL;
8042 1 : if(jarg2 != 0) {
8043 1 : const jclass vector = jenv->FindClass("java/util/Vector");
8044 1 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8045 1 : const jclass stringClass = jenv->FindClass("java/lang/String");
8046 1 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8047 : "()Ljava/util/Enumeration;");
8048 1 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8049 : "hasMoreElements", "()Z");
8050 1 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8051 : "nextElement", "()Ljava/lang/Object;");
8052 1 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8053 1 : hasMoreElements == NULL || getNextElement == NULL) {
8054 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8055 0 : return 0;
8056 : }
8057 2 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
8058 2 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8059 1 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8060 1 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8061 : {
8062 0 : CSLDestroy(arg2);
8063 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8064 0 : return 0;
8065 : }
8066 1 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8067 1 : arg2 = CSLAddString(arg2, valptr);
8068 1 : jenv->ReleaseStringUTFChars(value, valptr);
8069 : }
8070 : }
8071 : }
8072 1 : arg3 = 0;
8073 1 : if (jarg3) {
8074 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
8075 0 : if (!arg3) return 0;
8076 : }
8077 1 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_0(arg1,arg2,(char const *)arg3);
8078 1 : jresult = (jint)result;
8079 : {
8080 : /* %typemap(freearg) char **options */
8081 1 : CSLDestroy( arg2 );
8082 : }
8083 1 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
8084 1 : return jresult;
8085 : }
8086 :
8087 :
8088 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadata_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
8089 0 : jint jresult = 0 ;
8090 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8091 0 : char **arg2 = (char **) 0 ;
8092 : CPLErr result;
8093 :
8094 : (void)jenv;
8095 : (void)jcls;
8096 : (void)jarg1_;
8097 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8098 : {
8099 : /* %typemap(in) char **options */
8100 0 : arg2 = NULL;
8101 0 : if(jarg2 != 0) {
8102 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8103 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8104 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8105 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8106 : "()Ljava/util/Enumeration;");
8107 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8108 : "hasMoreElements", "()Z");
8109 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8110 : "nextElement", "()Ljava/lang/Object;");
8111 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8112 0 : hasMoreElements == NULL || getNextElement == NULL) {
8113 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8114 0 : return 0;
8115 : }
8116 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
8117 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8118 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8119 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8120 : {
8121 0 : CSLDestroy(arg2);
8122 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8123 0 : return 0;
8124 : }
8125 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8126 0 : arg2 = CSLAddString(arg2, valptr);
8127 0 : jenv->ReleaseStringUTFChars(value, valptr);
8128 : }
8129 : }
8130 : }
8131 0 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_0(arg1,arg2);
8132 0 : jresult = (jint)result;
8133 : {
8134 : /* %typemap(freearg) char **options */
8135 0 : CSLDestroy( arg2 );
8136 : }
8137 0 : return jresult;
8138 : }
8139 :
8140 :
8141 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadata_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
8142 0 : jint jresult = 0 ;
8143 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8144 0 : char *arg2 = (char *) 0 ;
8145 0 : char *arg3 = (char *) 0 ;
8146 : CPLErr result;
8147 :
8148 : (void)jenv;
8149 : (void)jcls;
8150 : (void)jarg1_;
8151 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8152 0 : arg2 = 0;
8153 0 : if (jarg2) {
8154 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8155 0 : if (!arg2) return 0;
8156 : }
8157 0 : arg3 = 0;
8158 0 : if (jarg3) {
8159 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
8160 0 : if (!arg3) return 0;
8161 : }
8162 0 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_2(arg1,arg2,(char const *)arg3);
8163 0 : jresult = (jint)result;
8164 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8165 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
8166 0 : return jresult;
8167 : }
8168 :
8169 :
8170 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadata_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
8171 1 : jint jresult = 0 ;
8172 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8173 1 : char *arg2 = (char *) 0 ;
8174 : CPLErr result;
8175 :
8176 : (void)jenv;
8177 : (void)jcls;
8178 : (void)jarg1_;
8179 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8180 1 : arg2 = 0;
8181 1 : if (jarg2) {
8182 1 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8183 1 : if (!arg2) return 0;
8184 : }
8185 1 : result = (CPLErr)GDALMajorObjectShadow_SetMetadata__SWIG_2(arg1,arg2);
8186 1 : jresult = (jint)result;
8187 1 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8188 1 : return jresult;
8189 : }
8190 :
8191 :
8192 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadataItem_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
8193 0 : jstring jresult = 0 ;
8194 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8195 0 : char *arg2 = (char *) 0 ;
8196 0 : char *arg3 = (char *) 0 ;
8197 0 : char *result = 0 ;
8198 :
8199 : (void)jenv;
8200 : (void)jcls;
8201 : (void)jarg1_;
8202 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8203 0 : arg2 = 0;
8204 0 : if (jarg2) {
8205 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8206 0 : if (!arg2) return 0;
8207 : }
8208 0 : arg3 = 0;
8209 0 : if (jarg3) {
8210 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
8211 0 : if (!arg3) return 0;
8212 : }
8213 : {
8214 0 : if (!arg2) {
8215 : {
8216 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8217 : };
8218 : }
8219 : }
8220 0 : result = (char *)GDALMajorObjectShadow_GetMetadataItem__SWIG_0(arg1,(char const *)arg2,(char const *)arg3);
8221 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
8222 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8223 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
8224 0 : return jresult;
8225 : }
8226 :
8227 :
8228 3 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1GetMetadataItem_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
8229 3 : jstring jresult = 0 ;
8230 3 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8231 3 : char *arg2 = (char *) 0 ;
8232 3 : char *result = 0 ;
8233 :
8234 : (void)jenv;
8235 : (void)jcls;
8236 : (void)jarg1_;
8237 3 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8238 3 : arg2 = 0;
8239 3 : if (jarg2) {
8240 3 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8241 3 : if (!arg2) return 0;
8242 : }
8243 : {
8244 3 : if (!arg2) {
8245 : {
8246 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8247 : };
8248 : }
8249 : }
8250 3 : result = (char *)GDALMajorObjectShadow_GetMetadataItem__SWIG_0(arg1,(char const *)arg2);
8251 3 : if (result) jresult = jenv->NewStringUTF((const char *)result);
8252 3 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8253 3 : return jresult;
8254 : }
8255 :
8256 :
8257 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadataItem_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
8258 0 : jint jresult = 0 ;
8259 0 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8260 0 : char *arg2 = (char *) 0 ;
8261 0 : char *arg3 = (char *) 0 ;
8262 0 : char *arg4 = (char *) 0 ;
8263 : CPLErr result;
8264 :
8265 : (void)jenv;
8266 : (void)jcls;
8267 : (void)jarg1_;
8268 0 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8269 0 : arg2 = 0;
8270 0 : if (jarg2) {
8271 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8272 0 : if (!arg2) return 0;
8273 : }
8274 0 : arg3 = 0;
8275 0 : if (jarg3) {
8276 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
8277 0 : if (!arg3) return 0;
8278 : }
8279 0 : arg4 = 0;
8280 0 : if (jarg4) {
8281 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
8282 0 : if (!arg4) return 0;
8283 : }
8284 : {
8285 0 : if (!arg2) {
8286 : {
8287 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8288 : };
8289 : }
8290 : }
8291 0 : result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem__SWIG_0(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4);
8292 0 : jresult = (jint)result;
8293 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8294 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
8295 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
8296 0 : return jresult;
8297 : }
8298 :
8299 :
8300 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MajorObject_1SetMetadataItem_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
8301 1 : jint jresult = 0 ;
8302 1 : GDALMajorObjectShadow *arg1 = (GDALMajorObjectShadow *) 0 ;
8303 1 : char *arg2 = (char *) 0 ;
8304 1 : char *arg3 = (char *) 0 ;
8305 : CPLErr result;
8306 :
8307 : (void)jenv;
8308 : (void)jcls;
8309 : (void)jarg1_;
8310 1 : arg1 = *(GDALMajorObjectShadow **)&jarg1;
8311 1 : arg2 = 0;
8312 1 : if (jarg2) {
8313 1 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8314 1 : if (!arg2) return 0;
8315 : }
8316 1 : arg3 = 0;
8317 1 : if (jarg3) {
8318 1 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
8319 1 : if (!arg3) return 0;
8320 : }
8321 : {
8322 1 : if (!arg2) {
8323 : {
8324 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8325 : };
8326 : }
8327 : }
8328 1 : result = (CPLErr)GDALMajorObjectShadow_SetMetadataItem__SWIG_0(arg1,(char const *)arg2,(char const *)arg3);
8329 1 : jresult = (jint)result;
8330 1 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8331 1 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
8332 1 : return jresult;
8333 : }
8334 :
8335 :
8336 1 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1ShortName_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
8337 1 : jstring jresult = 0 ;
8338 1 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8339 1 : char *result = 0 ;
8340 :
8341 : (void)jenv;
8342 : (void)jcls;
8343 : (void)jarg1_;
8344 1 : arg1 = *(GDALDriverShadow **)&jarg1;
8345 1 : result = (char *)GDALDriverShadow_ShortName_get(arg1);
8346 1 : if (result) jresult = jenv->NewStringUTF((const char *)result);
8347 1 : return jresult;
8348 : }
8349 :
8350 :
8351 1 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1LongName_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
8352 1 : jstring jresult = 0 ;
8353 1 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8354 1 : char *result = 0 ;
8355 :
8356 : (void)jenv;
8357 : (void)jcls;
8358 : (void)jarg1_;
8359 1 : arg1 = *(GDALDriverShadow **)&jarg1;
8360 1 : result = (char *)GDALDriverShadow_LongName_get(arg1);
8361 1 : if (result) jresult = jenv->NewStringUTF((const char *)result);
8362 1 : return jresult;
8363 : }
8364 :
8365 :
8366 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1HelpTopic_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
8367 0 : jstring jresult = 0 ;
8368 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8369 0 : char *result = 0 ;
8370 :
8371 : (void)jenv;
8372 : (void)jcls;
8373 : (void)jarg1_;
8374 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8375 0 : result = (char *)GDALDriverShadow_HelpTopic_get(arg1);
8376 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
8377 0 : return jresult;
8378 : }
8379 :
8380 :
8381 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Create_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jobject jarg7) {
8382 0 : jlong jresult = 0 ;
8383 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8384 0 : char *arg2 = (char *) 0 ;
8385 : int arg3 ;
8386 : int arg4 ;
8387 : int arg5 ;
8388 : GDALDataType arg6 ;
8389 0 : char **arg7 = (char **) 0 ;
8390 0 : GDALDatasetShadow *result = 0 ;
8391 :
8392 : (void)jenv;
8393 : (void)jcls;
8394 : (void)jarg1_;
8395 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8396 0 : arg2 = 0;
8397 0 : if (jarg2) {
8398 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8399 0 : if (!arg2) return 0;
8400 : }
8401 0 : arg3 = (int)jarg3;
8402 0 : arg4 = (int)jarg4;
8403 0 : arg5 = (int)jarg5;
8404 0 : arg6 = (GDALDataType)jarg6;
8405 : {
8406 : /* %typemap(in) char **options */
8407 0 : arg7 = NULL;
8408 0 : if(jarg7 != 0) {
8409 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8410 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8411 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8412 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8413 : "()Ljava/util/Enumeration;");
8414 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8415 : "hasMoreElements", "()Z");
8416 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8417 : "nextElement", "()Ljava/lang/Object;");
8418 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8419 0 : hasMoreElements == NULL || getNextElement == NULL) {
8420 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8421 0 : return 0;
8422 : }
8423 0 : for (jobject keys = jenv->CallObjectMethod(jarg7, elements);
8424 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8425 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8426 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8427 : {
8428 0 : CSLDestroy(arg7);
8429 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8430 0 : return 0;
8431 : }
8432 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8433 0 : arg7 = CSLAddString(arg7, valptr);
8434 0 : jenv->ReleaseStringUTFChars(value, valptr);
8435 : }
8436 : }
8437 : }
8438 : {
8439 0 : if (!arg2) {
8440 : {
8441 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8442 : };
8443 : }
8444 : }
8445 0 : result = (GDALDatasetShadow *)GDALDriverShadow_Create__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
8446 0 : *(GDALDatasetShadow **)&jresult = result;
8447 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8448 : {
8449 : /* %typemap(freearg) char **options */
8450 0 : CSLDestroy( arg7 );
8451 : }
8452 0 : return jresult;
8453 : }
8454 :
8455 :
8456 3 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Create_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6) {
8457 3 : jlong jresult = 0 ;
8458 3 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8459 3 : char *arg2 = (char *) 0 ;
8460 : int arg3 ;
8461 : int arg4 ;
8462 : int arg5 ;
8463 : GDALDataType arg6 ;
8464 3 : GDALDatasetShadow *result = 0 ;
8465 :
8466 : (void)jenv;
8467 : (void)jcls;
8468 : (void)jarg1_;
8469 3 : arg1 = *(GDALDriverShadow **)&jarg1;
8470 3 : arg2 = 0;
8471 3 : if (jarg2) {
8472 3 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8473 3 : if (!arg2) return 0;
8474 : }
8475 3 : arg3 = (int)jarg3;
8476 3 : arg4 = (int)jarg4;
8477 3 : arg5 = (int)jarg5;
8478 3 : arg6 = (GDALDataType)jarg6;
8479 : {
8480 3 : if (!arg2) {
8481 : {
8482 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8483 : };
8484 : }
8485 : }
8486 3 : result = (GDALDatasetShadow *)GDALDriverShadow_Create__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
8487 3 : *(GDALDatasetShadow **)&jresult = result;
8488 3 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8489 3 : return jresult;
8490 : }
8491 :
8492 :
8493 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Create_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4, jint jarg5) {
8494 0 : jlong jresult = 0 ;
8495 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8496 0 : char *arg2 = (char *) 0 ;
8497 : int arg3 ;
8498 : int arg4 ;
8499 : int arg5 ;
8500 0 : GDALDatasetShadow *result = 0 ;
8501 :
8502 : (void)jenv;
8503 : (void)jcls;
8504 : (void)jarg1_;
8505 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8506 0 : arg2 = 0;
8507 0 : if (jarg2) {
8508 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8509 0 : if (!arg2) return 0;
8510 : }
8511 0 : arg3 = (int)jarg3;
8512 0 : arg4 = (int)jarg4;
8513 0 : arg5 = (int)jarg5;
8514 : {
8515 0 : if (!arg2) {
8516 : {
8517 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8518 : };
8519 : }
8520 : }
8521 0 : result = (GDALDatasetShadow *)GDALDriverShadow_Create__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
8522 0 : *(GDALDatasetShadow **)&jresult = result;
8523 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8524 0 : return jresult;
8525 : }
8526 :
8527 :
8528 3 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Create_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
8529 3 : jlong jresult = 0 ;
8530 3 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8531 3 : char *arg2 = (char *) 0 ;
8532 : int arg3 ;
8533 : int arg4 ;
8534 3 : GDALDatasetShadow *result = 0 ;
8535 :
8536 : (void)jenv;
8537 : (void)jcls;
8538 : (void)jarg1_;
8539 3 : arg1 = *(GDALDriverShadow **)&jarg1;
8540 3 : arg2 = 0;
8541 3 : if (jarg2) {
8542 3 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8543 3 : if (!arg2) return 0;
8544 : }
8545 3 : arg3 = (int)jarg3;
8546 3 : arg4 = (int)jarg4;
8547 : {
8548 3 : if (!arg2) {
8549 : {
8550 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8551 : };
8552 : }
8553 : }
8554 3 : result = (GDALDatasetShadow *)GDALDriverShadow_Create__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
8555 3 : *(GDALDatasetShadow **)&jresult = result;
8556 3 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8557 3 : return jresult;
8558 : }
8559 :
8560 :
8561 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateMultiDimensional_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3, jobject jarg4) {
8562 0 : jlong jresult = 0 ;
8563 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8564 0 : char *arg2 = (char *) 0 ;
8565 0 : char **arg3 = (char **) 0 ;
8566 0 : char **arg4 = (char **) 0 ;
8567 0 : GDALDatasetShadow *result = 0 ;
8568 :
8569 : (void)jenv;
8570 : (void)jcls;
8571 : (void)jarg1_;
8572 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8573 0 : arg2 = 0;
8574 0 : if (jarg2) {
8575 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8576 0 : if (!arg2) return 0;
8577 : }
8578 : {
8579 : /* %typemap(in) char **options */
8580 0 : arg3 = NULL;
8581 0 : if(jarg3 != 0) {
8582 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8583 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8584 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8585 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8586 : "()Ljava/util/Enumeration;");
8587 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8588 : "hasMoreElements", "()Z");
8589 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8590 : "nextElement", "()Ljava/lang/Object;");
8591 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8592 0 : hasMoreElements == NULL || getNextElement == NULL) {
8593 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8594 0 : return 0;
8595 : }
8596 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
8597 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8598 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8599 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8600 : {
8601 0 : CSLDestroy(arg3);
8602 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8603 0 : return 0;
8604 : }
8605 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8606 0 : arg3 = CSLAddString(arg3, valptr);
8607 0 : jenv->ReleaseStringUTFChars(value, valptr);
8608 : }
8609 : }
8610 : }
8611 : {
8612 : /* %typemap(in) char **options */
8613 0 : arg4 = NULL;
8614 0 : if(jarg4 != 0) {
8615 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8616 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8617 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8618 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8619 : "()Ljava/util/Enumeration;");
8620 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8621 : "hasMoreElements", "()Z");
8622 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8623 : "nextElement", "()Ljava/lang/Object;");
8624 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8625 0 : hasMoreElements == NULL || getNextElement == NULL) {
8626 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8627 0 : return 0;
8628 : }
8629 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
8630 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8631 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8632 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8633 : {
8634 0 : CSLDestroy(arg4);
8635 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8636 0 : return 0;
8637 : }
8638 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8639 0 : arg4 = CSLAddString(arg4, valptr);
8640 0 : jenv->ReleaseStringUTFChars(value, valptr);
8641 : }
8642 : }
8643 : }
8644 : {
8645 0 : if (!arg2) {
8646 : {
8647 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8648 : };
8649 : }
8650 : }
8651 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateMultiDimensional__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
8652 0 : *(GDALDatasetShadow **)&jresult = result;
8653 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8654 : {
8655 : /* %typemap(freearg) char **options */
8656 0 : CSLDestroy( arg3 );
8657 : }
8658 : {
8659 : /* %typemap(freearg) char **options */
8660 0 : CSLDestroy( arg4 );
8661 : }
8662 0 : return jresult;
8663 : }
8664 :
8665 :
8666 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateMultiDimensional_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
8667 0 : jlong jresult = 0 ;
8668 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8669 0 : char *arg2 = (char *) 0 ;
8670 0 : char **arg3 = (char **) 0 ;
8671 0 : GDALDatasetShadow *result = 0 ;
8672 :
8673 : (void)jenv;
8674 : (void)jcls;
8675 : (void)jarg1_;
8676 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8677 0 : arg2 = 0;
8678 0 : if (jarg2) {
8679 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8680 0 : if (!arg2) return 0;
8681 : }
8682 : {
8683 : /* %typemap(in) char **options */
8684 0 : arg3 = NULL;
8685 0 : if(jarg3 != 0) {
8686 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8687 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8688 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8689 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8690 : "()Ljava/util/Enumeration;");
8691 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8692 : "hasMoreElements", "()Z");
8693 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8694 : "nextElement", "()Ljava/lang/Object;");
8695 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8696 0 : hasMoreElements == NULL || getNextElement == NULL) {
8697 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8698 0 : return 0;
8699 : }
8700 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
8701 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8702 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8703 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8704 : {
8705 0 : CSLDestroy(arg3);
8706 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8707 0 : return 0;
8708 : }
8709 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8710 0 : arg3 = CSLAddString(arg3, valptr);
8711 0 : jenv->ReleaseStringUTFChars(value, valptr);
8712 : }
8713 : }
8714 : }
8715 : {
8716 0 : if (!arg2) {
8717 : {
8718 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8719 : };
8720 : }
8721 : }
8722 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateMultiDimensional__SWIG_0(arg1,(char const *)arg2,arg3);
8723 0 : *(GDALDatasetShadow **)&jresult = result;
8724 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8725 : {
8726 : /* %typemap(freearg) char **options */
8727 0 : CSLDestroy( arg3 );
8728 : }
8729 0 : return jresult;
8730 : }
8731 :
8732 :
8733 4 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateMultiDimensional_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
8734 4 : jlong jresult = 0 ;
8735 4 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8736 4 : char *arg2 = (char *) 0 ;
8737 4 : GDALDatasetShadow *result = 0 ;
8738 :
8739 : (void)jenv;
8740 : (void)jcls;
8741 : (void)jarg1_;
8742 4 : arg1 = *(GDALDriverShadow **)&jarg1;
8743 4 : arg2 = 0;
8744 4 : if (jarg2) {
8745 4 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8746 4 : if (!arg2) return 0;
8747 : }
8748 : {
8749 4 : if (!arg2) {
8750 : {
8751 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8752 : };
8753 : }
8754 : }
8755 4 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateMultiDimensional__SWIG_0(arg1,(char const *)arg2);
8756 4 : *(GDALDatasetShadow **)&jresult = result;
8757 4 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8758 4 : return jresult;
8759 : }
8760 :
8761 :
8762 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateCopy_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5, jobject jarg6) {
8763 0 : jlong jresult = 0 ;
8764 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8765 0 : char *arg2 = (char *) 0 ;
8766 0 : GDALDatasetShadow *arg3 = (GDALDatasetShadow *) 0 ;
8767 : int arg4 ;
8768 0 : char **arg5 = (char **) 0 ;
8769 : GDALProgressFunc arg6 ;
8770 0 : void *arg7 = (void *) 0 ;
8771 0 : GDALDatasetShadow *result = 0 ;
8772 :
8773 : (void)jenv;
8774 : (void)jcls;
8775 : JavaProgressData sProgressInfo;
8776 0 : sProgressInfo.jenv = jenv;
8777 0 : sProgressInfo.pJavaCallback = NULL;
8778 : (void)jarg1_;
8779 : (void)jarg3_;
8780 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8781 0 : arg2 = 0;
8782 0 : if (jarg2) {
8783 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8784 0 : if (!arg2) return 0;
8785 : }
8786 0 : arg3 = *(GDALDatasetShadow **)&jarg3;
8787 0 : arg4 = (int)jarg4;
8788 : {
8789 : /* %typemap(in) char **options */
8790 0 : arg5 = NULL;
8791 0 : if(jarg5 != 0) {
8792 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8793 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8794 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8795 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8796 : "()Ljava/util/Enumeration;");
8797 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8798 : "hasMoreElements", "()Z");
8799 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8800 : "nextElement", "()Ljava/lang/Object;");
8801 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8802 0 : hasMoreElements == NULL || getNextElement == NULL) {
8803 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8804 0 : return 0;
8805 : }
8806 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
8807 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8808 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8809 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8810 : {
8811 0 : CSLDestroy(arg5);
8812 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8813 0 : return 0;
8814 : }
8815 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8816 0 : arg5 = CSLAddString(arg5, valptr);
8817 0 : jenv->ReleaseStringUTFChars(value, valptr);
8818 : }
8819 : }
8820 : }
8821 : {
8822 0 : if ( jarg6 != 0 ) {
8823 0 : sProgressInfo.pJavaCallback = jarg6;
8824 0 : arg6 = JavaProgressProxy;
8825 0 : arg7 = &sProgressInfo;
8826 : }
8827 : else
8828 : {
8829 0 : arg6 = NULL;
8830 0 : arg7 = NULL;
8831 : }
8832 : }
8833 : {
8834 0 : if (!arg2) {
8835 : {
8836 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8837 : };
8838 : }
8839 : }
8840 : {
8841 0 : if (!arg3) {
8842 : {
8843 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8844 : };
8845 : }
8846 : }
8847 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateCopy__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
8848 0 : *(GDALDatasetShadow **)&jresult = result;
8849 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8850 : {
8851 : /* %typemap(freearg) char **options */
8852 0 : CSLDestroy( arg5 );
8853 : }
8854 0 : return jresult;
8855 : }
8856 :
8857 :
8858 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateCopy_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5) {
8859 0 : jlong jresult = 0 ;
8860 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8861 0 : char *arg2 = (char *) 0 ;
8862 0 : GDALDatasetShadow *arg3 = (GDALDatasetShadow *) 0 ;
8863 : int arg4 ;
8864 0 : char **arg5 = (char **) 0 ;
8865 0 : GDALDatasetShadow *result = 0 ;
8866 :
8867 : (void)jenv;
8868 : (void)jcls;
8869 : (void)jarg1_;
8870 : (void)jarg3_;
8871 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8872 0 : arg2 = 0;
8873 0 : if (jarg2) {
8874 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8875 0 : if (!arg2) return 0;
8876 : }
8877 0 : arg3 = *(GDALDatasetShadow **)&jarg3;
8878 0 : arg4 = (int)jarg4;
8879 : {
8880 : /* %typemap(in) char **options */
8881 0 : arg5 = NULL;
8882 0 : if(jarg5 != 0) {
8883 0 : const jclass vector = jenv->FindClass("java/util/Vector");
8884 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
8885 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
8886 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
8887 : "()Ljava/util/Enumeration;");
8888 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
8889 : "hasMoreElements", "()Z");
8890 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
8891 : "nextElement", "()Ljava/lang/Object;");
8892 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
8893 0 : hasMoreElements == NULL || getNextElement == NULL) {
8894 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
8895 0 : return 0;
8896 : }
8897 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
8898 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
8899 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
8900 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
8901 : {
8902 0 : CSLDestroy(arg5);
8903 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
8904 0 : return 0;
8905 : }
8906 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
8907 0 : arg5 = CSLAddString(arg5, valptr);
8908 0 : jenv->ReleaseStringUTFChars(value, valptr);
8909 : }
8910 : }
8911 : }
8912 : {
8913 0 : if (!arg2) {
8914 : {
8915 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8916 : };
8917 : }
8918 : }
8919 : {
8920 0 : if (!arg3) {
8921 : {
8922 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8923 : };
8924 : }
8925 : }
8926 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateCopy__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
8927 0 : *(GDALDatasetShadow **)&jresult = result;
8928 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8929 : {
8930 : /* %typemap(freearg) char **options */
8931 0 : CSLDestroy( arg5 );
8932 : }
8933 0 : return jresult;
8934 : }
8935 :
8936 :
8937 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateCopy_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4) {
8938 0 : jlong jresult = 0 ;
8939 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8940 0 : char *arg2 = (char *) 0 ;
8941 0 : GDALDatasetShadow *arg3 = (GDALDatasetShadow *) 0 ;
8942 : int arg4 ;
8943 0 : GDALDatasetShadow *result = 0 ;
8944 :
8945 : (void)jenv;
8946 : (void)jcls;
8947 : (void)jarg1_;
8948 : (void)jarg3_;
8949 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8950 0 : arg2 = 0;
8951 0 : if (jarg2) {
8952 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8953 0 : if (!arg2) return 0;
8954 : }
8955 0 : arg3 = *(GDALDatasetShadow **)&jarg3;
8956 0 : arg4 = (int)jarg4;
8957 : {
8958 0 : if (!arg2) {
8959 : {
8960 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8961 : };
8962 : }
8963 : }
8964 : {
8965 0 : if (!arg3) {
8966 : {
8967 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
8968 : };
8969 : }
8970 : }
8971 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateCopy__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
8972 0 : *(GDALDatasetShadow **)&jresult = result;
8973 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
8974 0 : return jresult;
8975 : }
8976 :
8977 :
8978 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CreateCopy_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
8979 0 : jlong jresult = 0 ;
8980 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
8981 0 : char *arg2 = (char *) 0 ;
8982 0 : GDALDatasetShadow *arg3 = (GDALDatasetShadow *) 0 ;
8983 0 : GDALDatasetShadow *result = 0 ;
8984 :
8985 : (void)jenv;
8986 : (void)jcls;
8987 : (void)jarg1_;
8988 : (void)jarg3_;
8989 0 : arg1 = *(GDALDriverShadow **)&jarg1;
8990 0 : arg2 = 0;
8991 0 : if (jarg2) {
8992 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
8993 0 : if (!arg2) return 0;
8994 : }
8995 0 : arg3 = *(GDALDatasetShadow **)&jarg3;
8996 : {
8997 0 : if (!arg2) {
8998 : {
8999 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9000 : };
9001 : }
9002 : }
9003 : {
9004 0 : if (!arg3) {
9005 : {
9006 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9007 : };
9008 : }
9009 : }
9010 0 : result = (GDALDatasetShadow *)GDALDriverShadow_CreateCopy__SWIG_0(arg1,(char const *)arg2,arg3);
9011 0 : *(GDALDatasetShadow **)&jresult = result;
9012 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9013 0 : return jresult;
9014 : }
9015 :
9016 :
9017 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Delete(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
9018 0 : jint jresult = 0 ;
9019 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
9020 0 : char *arg2 = (char *) 0 ;
9021 : CPLErr result;
9022 :
9023 : (void)jenv;
9024 : (void)jcls;
9025 : (void)jarg1_;
9026 0 : arg1 = *(GDALDriverShadow **)&jarg1;
9027 0 : arg2 = 0;
9028 0 : if (jarg2) {
9029 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9030 0 : if (!arg2) return 0;
9031 : }
9032 : {
9033 0 : if (!arg2) {
9034 : {
9035 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9036 : };
9037 : }
9038 : }
9039 0 : result = (CPLErr)GDALDriverShadow_Delete(arg1,(char const *)arg2);
9040 0 : jresult = (jint)result;
9041 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9042 0 : return jresult;
9043 : }
9044 :
9045 :
9046 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
9047 0 : jint jresult = 0 ;
9048 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
9049 0 : char *arg2 = (char *) 0 ;
9050 0 : char *arg3 = (char *) 0 ;
9051 : CPLErr result;
9052 :
9053 : (void)jenv;
9054 : (void)jcls;
9055 : (void)jarg1_;
9056 0 : arg1 = *(GDALDriverShadow **)&jarg1;
9057 0 : arg2 = 0;
9058 0 : if (jarg2) {
9059 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9060 0 : if (!arg2) return 0;
9061 : }
9062 0 : arg3 = 0;
9063 0 : if (jarg3) {
9064 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
9065 0 : if (!arg3) return 0;
9066 : }
9067 : {
9068 0 : if (!arg2) {
9069 : {
9070 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9071 : };
9072 : }
9073 : }
9074 : {
9075 0 : if (!arg3) {
9076 : {
9077 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9078 : };
9079 : }
9080 : }
9081 0 : result = (CPLErr)GDALDriverShadow_Rename(arg1,(char const *)arg2,(char const *)arg3);
9082 0 : jresult = (jint)result;
9083 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9084 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
9085 0 : return jresult;
9086 : }
9087 :
9088 :
9089 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1CopyFiles(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
9090 0 : jint jresult = 0 ;
9091 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
9092 0 : char *arg2 = (char *) 0 ;
9093 0 : char *arg3 = (char *) 0 ;
9094 : CPLErr result;
9095 :
9096 : (void)jenv;
9097 : (void)jcls;
9098 : (void)jarg1_;
9099 0 : arg1 = *(GDALDriverShadow **)&jarg1;
9100 0 : arg2 = 0;
9101 0 : if (jarg2) {
9102 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9103 0 : if (!arg2) return 0;
9104 : }
9105 0 : arg3 = 0;
9106 0 : if (jarg3) {
9107 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
9108 0 : if (!arg3) return 0;
9109 : }
9110 : {
9111 0 : if (!arg2) {
9112 : {
9113 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9114 : };
9115 : }
9116 : }
9117 : {
9118 0 : if (!arg3) {
9119 : {
9120 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9121 : };
9122 : }
9123 : }
9124 0 : result = (CPLErr)GDALDriverShadow_CopyFiles(arg1,(char const *)arg2,(char const *)arg3);
9125 0 : jresult = (jint)result;
9126 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9127 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
9128 0 : return jresult;
9129 : }
9130 :
9131 :
9132 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Register(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9133 0 : jint jresult = 0 ;
9134 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
9135 : int result;
9136 :
9137 : (void)jenv;
9138 : (void)jcls;
9139 : (void)jarg1_;
9140 0 : arg1 = *(GDALDriverShadow **)&jarg1;
9141 0 : result = (int)GDALDriverShadow_Register(arg1);
9142 0 : jresult = (jint)result;
9143 0 : return jresult;
9144 : }
9145 :
9146 :
9147 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1Deregister(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9148 0 : GDALDriverShadow *arg1 = (GDALDriverShadow *) 0 ;
9149 :
9150 : (void)jenv;
9151 : (void)jcls;
9152 : (void)jarg1_;
9153 0 : arg1 = *(GDALDriverShadow **)&jarg1;
9154 0 : GDALDriverShadow_Deregister(arg1);
9155 0 : }
9156 :
9157 :
9158 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9159 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9160 : double arg2 ;
9161 :
9162 : (void)jenv;
9163 : (void)jcls;
9164 : (void)jarg1_;
9165 0 : arg1 = *(GDAL_GCP **)&jarg1;
9166 0 : arg2 = (double)jarg2;
9167 0 : GDAL_GCP_GCPX_set(arg1,arg2);
9168 0 : }
9169 :
9170 :
9171 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9172 0 : jdouble jresult = 0 ;
9173 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9174 : double result;
9175 :
9176 : (void)jenv;
9177 : (void)jcls;
9178 : (void)jarg1_;
9179 0 : arg1 = *(GDAL_GCP **)&jarg1;
9180 0 : result = (double)GDAL_GCP_GCPX_get(arg1);
9181 0 : jresult = (jdouble)result;
9182 0 : return jresult;
9183 : }
9184 :
9185 :
9186 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9187 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9188 : double arg2 ;
9189 :
9190 : (void)jenv;
9191 : (void)jcls;
9192 : (void)jarg1_;
9193 0 : arg1 = *(GDAL_GCP **)&jarg1;
9194 0 : arg2 = (double)jarg2;
9195 0 : GDAL_GCP_GCPY_set(arg1,arg2);
9196 0 : }
9197 :
9198 :
9199 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9200 0 : jdouble jresult = 0 ;
9201 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9202 : double result;
9203 :
9204 : (void)jenv;
9205 : (void)jcls;
9206 : (void)jarg1_;
9207 0 : arg1 = *(GDAL_GCP **)&jarg1;
9208 0 : result = (double)GDAL_GCP_GCPY_get(arg1);
9209 0 : jresult = (jdouble)result;
9210 0 : return jresult;
9211 : }
9212 :
9213 :
9214 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPZ_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9215 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9216 : double arg2 ;
9217 :
9218 : (void)jenv;
9219 : (void)jcls;
9220 : (void)jarg1_;
9221 0 : arg1 = *(GDAL_GCP **)&jarg1;
9222 0 : arg2 = (double)jarg2;
9223 0 : GDAL_GCP_GCPZ_set(arg1,arg2);
9224 0 : }
9225 :
9226 :
9227 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPZ_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9228 0 : jdouble jresult = 0 ;
9229 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9230 : double result;
9231 :
9232 : (void)jenv;
9233 : (void)jcls;
9234 : (void)jarg1_;
9235 0 : arg1 = *(GDAL_GCP **)&jarg1;
9236 0 : result = (double)GDAL_GCP_GCPZ_get(arg1);
9237 0 : jresult = (jdouble)result;
9238 0 : return jresult;
9239 : }
9240 :
9241 :
9242 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPPixel_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9243 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9244 : double arg2 ;
9245 :
9246 : (void)jenv;
9247 : (void)jcls;
9248 : (void)jarg1_;
9249 0 : arg1 = *(GDAL_GCP **)&jarg1;
9250 0 : arg2 = (double)jarg2;
9251 0 : GDAL_GCP_GCPPixel_set(arg1,arg2);
9252 0 : }
9253 :
9254 :
9255 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPPixel_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9256 0 : jdouble jresult = 0 ;
9257 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9258 : double result;
9259 :
9260 : (void)jenv;
9261 : (void)jcls;
9262 : (void)jarg1_;
9263 0 : arg1 = *(GDAL_GCP **)&jarg1;
9264 0 : result = (double)GDAL_GCP_GCPPixel_get(arg1);
9265 0 : jresult = (jdouble)result;
9266 0 : return jresult;
9267 : }
9268 :
9269 :
9270 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPLine_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9271 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9272 : double arg2 ;
9273 :
9274 : (void)jenv;
9275 : (void)jcls;
9276 : (void)jarg1_;
9277 0 : arg1 = *(GDAL_GCP **)&jarg1;
9278 0 : arg2 = (double)jarg2;
9279 0 : GDAL_GCP_GCPLine_set(arg1,arg2);
9280 0 : }
9281 :
9282 :
9283 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1GCPLine_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9284 0 : jdouble jresult = 0 ;
9285 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9286 : double result;
9287 :
9288 : (void)jenv;
9289 : (void)jcls;
9290 : (void)jarg1_;
9291 0 : arg1 = *(GDAL_GCP **)&jarg1;
9292 0 : result = (double)GDAL_GCP_GCPLine_get(arg1);
9293 0 : jresult = (jdouble)result;
9294 0 : return jresult;
9295 : }
9296 :
9297 :
9298 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1Info_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
9299 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9300 0 : char *arg2 = (char *) 0 ;
9301 :
9302 : (void)jenv;
9303 : (void)jcls;
9304 : (void)jarg1_;
9305 0 : arg1 = *(GDAL_GCP **)&jarg1;
9306 0 : arg2 = 0;
9307 0 : if (jarg2) {
9308 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9309 0 : if (!arg2) return ;
9310 : }
9311 0 : GDAL_GCP_Info_set(arg1,arg2);
9312 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9313 : }
9314 :
9315 :
9316 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1Info_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9317 0 : jstring jresult = 0 ;
9318 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9319 0 : char *result = 0 ;
9320 :
9321 : (void)jenv;
9322 : (void)jcls;
9323 : (void)jarg1_;
9324 0 : arg1 = *(GDAL_GCP **)&jarg1;
9325 0 : result = (char *)GDAL_GCP_Info_get(arg1);
9326 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9327 0 : return jresult;
9328 : }
9329 :
9330 :
9331 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1Id_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
9332 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9333 0 : char *arg2 = (char *) 0 ;
9334 :
9335 : (void)jenv;
9336 : (void)jcls;
9337 : (void)jarg1_;
9338 0 : arg1 = *(GDAL_GCP **)&jarg1;
9339 0 : arg2 = 0;
9340 0 : if (jarg2) {
9341 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9342 0 : if (!arg2) return ;
9343 : }
9344 0 : GDAL_GCP_Id_set(arg1,arg2);
9345 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9346 : }
9347 :
9348 :
9349 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GCP_1Id_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9350 0 : jstring jresult = 0 ;
9351 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9352 0 : char *result = 0 ;
9353 :
9354 : (void)jenv;
9355 : (void)jcls;
9356 : (void)jarg1_;
9357 0 : arg1 = *(GDAL_GCP **)&jarg1;
9358 0 : result = (char *)GDAL_GCP_Id_get(arg1);
9359 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9360 0 : return jresult;
9361 : }
9362 :
9363 :
9364 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1GCP(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jstring jarg6, jstring jarg7) {
9365 0 : jlong jresult = 0 ;
9366 : double arg1 ;
9367 : double arg2 ;
9368 : double arg3 ;
9369 : double arg4 ;
9370 : double arg5 ;
9371 0 : char *arg6 = (char *) 0 ;
9372 0 : char *arg7 = (char *) 0 ;
9373 0 : GDAL_GCP *result = 0 ;
9374 :
9375 : (void)jenv;
9376 : (void)jcls;
9377 0 : arg1 = (double)jarg1;
9378 0 : arg2 = (double)jarg2;
9379 0 : arg3 = (double)jarg3;
9380 0 : arg4 = (double)jarg4;
9381 0 : arg5 = (double)jarg5;
9382 0 : arg6 = 0;
9383 0 : if (jarg6) {
9384 0 : arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0);
9385 0 : if (!arg6) return 0;
9386 : }
9387 0 : arg7 = 0;
9388 0 : if (jarg7) {
9389 0 : arg7 = (char *)jenv->GetStringUTFChars(jarg7, 0);
9390 0 : if (!arg7) return 0;
9391 : }
9392 0 : result = (GDAL_GCP *)new_GDAL_GCP(arg1,arg2,arg3,arg4,arg5,(char const *)arg6,(char const *)arg7);
9393 0 : *(GDAL_GCP **)&jresult = result;
9394 0 : if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6);
9395 0 : if (arg7) jenv->ReleaseStringUTFChars(jarg7, (const char *)arg7);
9396 0 : return jresult;
9397 : }
9398 :
9399 :
9400 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1GCP(JNIEnv *jenv, jclass jcls, jlong jarg1) {
9401 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9402 :
9403 : (void)jenv;
9404 : (void)jcls;
9405 0 : arg1 = *(GDAL_GCP **)&jarg1;
9406 0 : delete_GDAL_GCP(arg1);
9407 0 : }
9408 :
9409 :
9410 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPX_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9411 0 : jdouble jresult = 0 ;
9412 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9413 : double result;
9414 :
9415 : (void)jenv;
9416 : (void)jcls;
9417 : (void)jarg1_;
9418 0 : arg1 = *(GDAL_GCP **)&jarg1;
9419 : {
9420 0 : if (!arg1) {
9421 : {
9422 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9423 : };
9424 : }
9425 : }
9426 0 : result = (double)GDAL_GCP_GCPX_get(arg1);
9427 0 : jresult = (jdouble)result;
9428 0 : return jresult;
9429 : }
9430 :
9431 :
9432 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPX_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9433 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9434 : double arg2 ;
9435 :
9436 : (void)jenv;
9437 : (void)jcls;
9438 : (void)jarg1_;
9439 0 : arg1 = *(GDAL_GCP **)&jarg1;
9440 0 : arg2 = (double)jarg2;
9441 : {
9442 0 : if (!arg1) {
9443 : {
9444 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9445 : };
9446 : }
9447 : }
9448 0 : GDAL_GCP_GCPX_set(arg1,arg2);
9449 : }
9450 :
9451 :
9452 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPY_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9453 0 : jdouble jresult = 0 ;
9454 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9455 : double result;
9456 :
9457 : (void)jenv;
9458 : (void)jcls;
9459 : (void)jarg1_;
9460 0 : arg1 = *(GDAL_GCP **)&jarg1;
9461 : {
9462 0 : if (!arg1) {
9463 : {
9464 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9465 : };
9466 : }
9467 : }
9468 0 : result = (double)GDAL_GCP_GCPY_get(arg1);
9469 0 : jresult = (jdouble)result;
9470 0 : return jresult;
9471 : }
9472 :
9473 :
9474 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPY_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9475 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9476 : double arg2 ;
9477 :
9478 : (void)jenv;
9479 : (void)jcls;
9480 : (void)jarg1_;
9481 0 : arg1 = *(GDAL_GCP **)&jarg1;
9482 0 : arg2 = (double)jarg2;
9483 : {
9484 0 : if (!arg1) {
9485 : {
9486 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9487 : };
9488 : }
9489 : }
9490 0 : GDAL_GCP_GCPY_set(arg1,arg2);
9491 : }
9492 :
9493 :
9494 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPZ_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9495 0 : jdouble jresult = 0 ;
9496 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9497 : double result;
9498 :
9499 : (void)jenv;
9500 : (void)jcls;
9501 : (void)jarg1_;
9502 0 : arg1 = *(GDAL_GCP **)&jarg1;
9503 : {
9504 0 : if (!arg1) {
9505 : {
9506 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9507 : };
9508 : }
9509 : }
9510 0 : result = (double)GDAL_GCP_GCPZ_get(arg1);
9511 0 : jresult = (jdouble)result;
9512 0 : return jresult;
9513 : }
9514 :
9515 :
9516 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPZ_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9517 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9518 : double arg2 ;
9519 :
9520 : (void)jenv;
9521 : (void)jcls;
9522 : (void)jarg1_;
9523 0 : arg1 = *(GDAL_GCP **)&jarg1;
9524 0 : arg2 = (double)jarg2;
9525 : {
9526 0 : if (!arg1) {
9527 : {
9528 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9529 : };
9530 : }
9531 : }
9532 0 : GDAL_GCP_GCPZ_set(arg1,arg2);
9533 : }
9534 :
9535 :
9536 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPPixel_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9537 0 : jdouble jresult = 0 ;
9538 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9539 : double result;
9540 :
9541 : (void)jenv;
9542 : (void)jcls;
9543 : (void)jarg1_;
9544 0 : arg1 = *(GDAL_GCP **)&jarg1;
9545 : {
9546 0 : if (!arg1) {
9547 : {
9548 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9549 : };
9550 : }
9551 : }
9552 0 : result = (double)GDAL_GCP_GCPPixel_get(arg1);
9553 0 : jresult = (jdouble)result;
9554 0 : return jresult;
9555 : }
9556 :
9557 :
9558 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPPixel_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9559 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9560 : double arg2 ;
9561 :
9562 : (void)jenv;
9563 : (void)jcls;
9564 : (void)jarg1_;
9565 0 : arg1 = *(GDAL_GCP **)&jarg1;
9566 0 : arg2 = (double)jarg2;
9567 : {
9568 0 : if (!arg1) {
9569 : {
9570 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9571 : };
9572 : }
9573 : }
9574 0 : GDAL_GCP_GCPPixel_set(arg1,arg2);
9575 : }
9576 :
9577 :
9578 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPLine_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9579 0 : jdouble jresult = 0 ;
9580 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9581 : double result;
9582 :
9583 : (void)jenv;
9584 : (void)jcls;
9585 : (void)jarg1_;
9586 0 : arg1 = *(GDAL_GCP **)&jarg1;
9587 : {
9588 0 : if (!arg1) {
9589 : {
9590 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9591 : };
9592 : }
9593 : }
9594 0 : result = (double)GDAL_GCP_GCPLine_get(arg1);
9595 0 : jresult = (jdouble)result;
9596 0 : return jresult;
9597 : }
9598 :
9599 :
9600 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1GCPLine_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
9601 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9602 : double arg2 ;
9603 :
9604 : (void)jenv;
9605 : (void)jcls;
9606 : (void)jarg1_;
9607 0 : arg1 = *(GDAL_GCP **)&jarg1;
9608 0 : arg2 = (double)jarg2;
9609 : {
9610 0 : if (!arg1) {
9611 : {
9612 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9613 : };
9614 : }
9615 : }
9616 0 : GDAL_GCP_GCPLine_set(arg1,arg2);
9617 : }
9618 :
9619 :
9620 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1Info_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9621 0 : jstring jresult = 0 ;
9622 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9623 0 : char *result = 0 ;
9624 :
9625 : (void)jenv;
9626 : (void)jcls;
9627 : (void)jarg1_;
9628 0 : arg1 = *(GDAL_GCP **)&jarg1;
9629 : {
9630 0 : if (!arg1) {
9631 : {
9632 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9633 : };
9634 : }
9635 : }
9636 0 : result = (char *)GDAL_GCP_Info_get(arg1);
9637 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9638 0 : return jresult;
9639 : }
9640 :
9641 :
9642 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1Info_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
9643 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9644 0 : char *arg2 = (char *) 0 ;
9645 :
9646 : (void)jenv;
9647 : (void)jcls;
9648 : (void)jarg1_;
9649 0 : arg1 = *(GDAL_GCP **)&jarg1;
9650 0 : arg2 = 0;
9651 0 : if (jarg2) {
9652 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9653 0 : if (!arg2) return ;
9654 : }
9655 : {
9656 0 : if (!arg1) {
9657 : {
9658 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9659 : };
9660 : }
9661 : }
9662 0 : GDAL_GCP_Info_set(arg1,(char const *)arg2);
9663 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9664 : }
9665 :
9666 :
9667 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1Id_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9668 0 : jstring jresult = 0 ;
9669 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9670 0 : char *result = 0 ;
9671 :
9672 : (void)jenv;
9673 : (void)jcls;
9674 : (void)jarg1_;
9675 0 : arg1 = *(GDAL_GCP **)&jarg1;
9676 : {
9677 0 : if (!arg1) {
9678 : {
9679 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
9680 : };
9681 : }
9682 : }
9683 0 : result = (char *)GDAL_GCP_Id_get(arg1);
9684 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9685 0 : return jresult;
9686 : }
9687 :
9688 :
9689 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDAL_1GCP_1Id_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
9690 0 : GDAL_GCP *arg1 = (GDAL_GCP *) 0 ;
9691 0 : char *arg2 = (char *) 0 ;
9692 :
9693 : (void)jenv;
9694 : (void)jcls;
9695 : (void)jarg1_;
9696 0 : arg1 = *(GDAL_GCP **)&jarg1;
9697 0 : arg2 = 0;
9698 0 : if (jarg2) {
9699 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
9700 0 : if (!arg2) return ;
9701 : }
9702 : {
9703 0 : if (!arg1) {
9704 : {
9705 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return ;
9706 : };
9707 : }
9708 : }
9709 0 : GDAL_GCP_Id_set(arg1,(char const *)arg2);
9710 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
9711 : }
9712 :
9713 :
9714 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GCPsToGeoTransform_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdoubleArray jarg3, jint jarg4) {
9715 0 : jint jresult = 0 ;
9716 : int arg1 ;
9717 0 : GDAL_GCP *arg2 = (GDAL_GCP *) 0 ;
9718 : double *arg3 ;
9719 : int arg4 ;
9720 : int result;
9721 :
9722 : (void)jenv;
9723 : (void)jcls;
9724 : {
9725 : /* %typemap(in, numinputs=1) (int nGCPs, GDAL_GCP const * pGCPs) */
9726 0 : if (jarg1)
9727 : {
9728 0 : arg1 = jenv->GetArrayLength(jarg1);
9729 0 : if (arg1 == 0)
9730 0 : arg2 = NULL;
9731 : else
9732 : {
9733 0 : arg2 = (GDAL_GCP*) malloc(sizeof(GDAL_GCP) * arg1);
9734 : int i;
9735 0 : for (i=0; i<arg1; i++) {
9736 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg1, i);
9737 0 : if (obj == NULL)
9738 : {
9739 0 : free (arg2 );
9740 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
9741 0 : return 0;
9742 : }
9743 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/GCP");
9744 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/GCP;)J");
9745 0 : arg2[i] = *(GDAL_GCP*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
9746 : }
9747 : }
9748 : }
9749 : else
9750 : {
9751 0 : arg1 = 0;
9752 0 : arg2 = NULL;
9753 : }
9754 : }
9755 : {
9756 : /* %typemap(in) (double argout[ANY]) */
9757 0 : if(jarg3 == NULL || jenv->GetArrayLength(jarg3) != 6) {
9758 : char errorMsg[512];
9759 0 : sprintf(errorMsg, "array of size %d expected", 6);
9760 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
9761 0 : return 0;
9762 : }
9763 0 : arg3 = (double *)jenv->GetDoubleArrayElements(jarg3, NULL);
9764 : }
9765 0 : arg4 = (int)jarg4;
9766 0 : result = (int)wrapper_GDALGCPsToGeoTransform(arg1,(GDAL_GCP const *)arg2,arg3,arg4);
9767 0 : jresult = (jint)result;
9768 : {
9769 : /* %typemap(argout) (double argout[ANY]) */
9770 : }
9771 : {
9772 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const * pGCPs) */
9773 0 : if (arg2) {
9774 0 : free((void*) arg2);
9775 : }
9776 : }
9777 : {
9778 : /* %typemap(freearg) (double argout[ANY]) */
9779 0 : jenv->ReleaseDoubleArrayElements(jarg3, (jdouble *)arg3, 0);
9780 : }
9781 0 : return jresult;
9782 : }
9783 :
9784 :
9785 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GCPsToGeoTransform_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdoubleArray jarg3) {
9786 0 : jint jresult = 0 ;
9787 : int arg1 ;
9788 0 : GDAL_GCP *arg2 = (GDAL_GCP *) 0 ;
9789 : double *arg3 ;
9790 : int result;
9791 :
9792 : (void)jenv;
9793 : (void)jcls;
9794 : {
9795 : /* %typemap(in, numinputs=1) (int nGCPs, GDAL_GCP const * pGCPs) */
9796 0 : if (jarg1)
9797 : {
9798 0 : arg1 = jenv->GetArrayLength(jarg1);
9799 0 : if (arg1 == 0)
9800 0 : arg2 = NULL;
9801 : else
9802 : {
9803 0 : arg2 = (GDAL_GCP*) malloc(sizeof(GDAL_GCP) * arg1);
9804 : int i;
9805 0 : for (i=0; i<arg1; i++) {
9806 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg1, i);
9807 0 : if (obj == NULL)
9808 : {
9809 0 : free (arg2 );
9810 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
9811 0 : return 0;
9812 : }
9813 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/GCP");
9814 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/GCP;)J");
9815 0 : arg2[i] = *(GDAL_GCP*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
9816 : }
9817 : }
9818 : }
9819 : else
9820 : {
9821 0 : arg1 = 0;
9822 0 : arg2 = NULL;
9823 : }
9824 : }
9825 : {
9826 : /* %typemap(in) (double argout[ANY]) */
9827 0 : if(jarg3 == NULL || jenv->GetArrayLength(jarg3) != 6) {
9828 : char errorMsg[512];
9829 0 : sprintf(errorMsg, "array of size %d expected", 6);
9830 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
9831 0 : return 0;
9832 : }
9833 0 : arg3 = (double *)jenv->GetDoubleArrayElements(jarg3, NULL);
9834 : }
9835 0 : result = (int)wrapper_GDALGCPsToGeoTransform(arg1,(GDAL_GCP const *)arg2,arg3);
9836 0 : jresult = (jint)result;
9837 : {
9838 : /* %typemap(argout) (double argout[ANY]) */
9839 : }
9840 : {
9841 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const * pGCPs) */
9842 0 : if (arg2) {
9843 0 : free((void*) arg2);
9844 : }
9845 : }
9846 : {
9847 : /* %typemap(freearg) (double argout[ANY]) */
9848 0 : jenv->ReleaseDoubleArrayElements(jarg3, (jdouble *)arg3, 0);
9849 : }
9850 0 : return jresult;
9851 : }
9852 :
9853 :
9854 5 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1RasterXSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9855 5 : jint jresult = 0 ;
9856 5 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9857 : int result;
9858 :
9859 : (void)jenv;
9860 : (void)jcls;
9861 : (void)jarg1_;
9862 5 : arg1 = *(GDALDatasetShadow **)&jarg1;
9863 5 : result = (int)GDALDatasetShadow_RasterXSize_get(arg1);
9864 5 : jresult = (jint)result;
9865 5 : return jresult;
9866 : }
9867 :
9868 :
9869 5 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1RasterYSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9870 5 : jint jresult = 0 ;
9871 5 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9872 : int result;
9873 :
9874 : (void)jenv;
9875 : (void)jcls;
9876 : (void)jarg1_;
9877 5 : arg1 = *(GDALDatasetShadow **)&jarg1;
9878 5 : result = (int)GDALDatasetShadow_RasterYSize_get(arg1);
9879 5 : jresult = (jint)result;
9880 5 : return jresult;
9881 : }
9882 :
9883 :
9884 5 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1RasterCount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9885 5 : jint jresult = 0 ;
9886 5 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9887 : int result;
9888 :
9889 : (void)jenv;
9890 : (void)jcls;
9891 : (void)jarg1_;
9892 5 : arg1 = *(GDALDatasetShadow **)&jarg1;
9893 5 : result = (int)GDALDatasetShadow_RasterCount_get(arg1);
9894 5 : jresult = (jint)result;
9895 5 : return jresult;
9896 : }
9897 :
9898 :
9899 9 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Dataset(JNIEnv *jenv, jclass jcls, jlong jarg1) {
9900 9 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9901 :
9902 : (void)jenv;
9903 : (void)jcls;
9904 9 : arg1 = *(GDALDatasetShadow **)&jarg1;
9905 9 : delete_GDALDatasetShadow(arg1);
9906 9 : }
9907 :
9908 :
9909 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1Close(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9910 0 : jint jresult = 0 ;
9911 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9912 : CPLErr result;
9913 :
9914 : (void)jenv;
9915 : (void)jcls;
9916 : (void)jarg1_;
9917 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
9918 0 : result = (CPLErr)GDALDatasetShadow_Close(arg1);
9919 0 : jresult = (jint)result;
9920 0 : return jresult;
9921 : }
9922 :
9923 :
9924 1 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetDriver(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9925 1 : jlong jresult = 0 ;
9926 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9927 1 : GDALDriverShadow *result = 0 ;
9928 :
9929 : (void)jenv;
9930 : (void)jcls;
9931 : (void)jarg1_;
9932 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
9933 1 : result = (GDALDriverShadow *)GDALDatasetShadow_GetDriver(arg1);
9934 1 : *(GDALDriverShadow **)&jresult = result;
9935 1 : return jresult;
9936 : }
9937 :
9938 :
9939 9 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetRasterBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
9940 9 : jlong jresult = 0 ;
9941 9 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9942 : int arg2 ;
9943 9 : GDALRasterBandShadow *result = 0 ;
9944 :
9945 : (void)jenv;
9946 : (void)jcls;
9947 : (void)jarg1_;
9948 9 : arg1 = *(GDALDatasetShadow **)&jarg1;
9949 9 : arg2 = (int)jarg2;
9950 9 : result = (GDALRasterBandShadow *)GDALDatasetShadow_GetRasterBand(arg1,arg2);
9951 9 : *(GDALRasterBandShadow **)&jresult = result;
9952 9 : return jresult;
9953 : }
9954 :
9955 :
9956 4 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetRootGroup(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9957 4 : jlong jresult = 0 ;
9958 4 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9959 4 : GDALGroupHS *result = 0 ;
9960 :
9961 : (void)jenv;
9962 : (void)jcls;
9963 : (void)jarg1_;
9964 4 : arg1 = *(GDALDatasetShadow **)&jarg1;
9965 4 : result = (GDALGroupHS *)GDALDatasetShadow_GetRootGroup(arg1);
9966 4 : *(GDALGroupHS **)&jresult = result;
9967 4 : return jresult;
9968 : }
9969 :
9970 :
9971 1 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetProjection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9972 1 : jstring jresult = 0 ;
9973 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9974 1 : char *result = 0 ;
9975 :
9976 : (void)jenv;
9977 : (void)jcls;
9978 : (void)jarg1_;
9979 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
9980 1 : result = (char *)GDALDatasetShadow_GetProjection(arg1);
9981 1 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9982 1 : return jresult;
9983 : }
9984 :
9985 :
9986 8 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetProjectionRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
9987 8 : jstring jresult = 0 ;
9988 8 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
9989 8 : char *result = 0 ;
9990 :
9991 : (void)jenv;
9992 : (void)jcls;
9993 : (void)jarg1_;
9994 8 : arg1 = *(GDALDatasetShadow **)&jarg1;
9995 8 : result = (char *)GDALDatasetShadow_GetProjectionRef(arg1);
9996 8 : if (result) jresult = jenv->NewStringUTF((const char *)result);
9997 8 : return jresult;
9998 : }
9999 :
10000 :
10001 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetSpatialRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10002 0 : jlong jresult = 0 ;
10003 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10004 0 : OSRSpatialReferenceShadow *result = 0 ;
10005 :
10006 : (void)jenv;
10007 : (void)jcls;
10008 : (void)jarg1_;
10009 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10010 0 : result = (OSRSpatialReferenceShadow *)GDALDatasetShadow_GetSpatialRef(arg1);
10011 0 : *(OSRSpatialReferenceShadow **)&jresult = result;
10012 0 : return jresult;
10013 : }
10014 :
10015 :
10016 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetProjection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
10017 0 : jint jresult = 0 ;
10018 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10019 0 : char *arg2 = (char *) 0 ;
10020 : CPLErr result;
10021 :
10022 : (void)jenv;
10023 : (void)jcls;
10024 : (void)jarg1_;
10025 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10026 0 : arg2 = 0;
10027 0 : if (jarg2) {
10028 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
10029 0 : if (!arg2) return 0;
10030 : }
10031 : {
10032 0 : if (!arg2) {
10033 : {
10034 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
10035 : };
10036 : }
10037 : }
10038 0 : result = (CPLErr)GDALDatasetShadow_SetProjection(arg1,(char const *)arg2);
10039 0 : jresult = (jint)result;
10040 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
10041 0 : return jresult;
10042 : }
10043 :
10044 :
10045 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetSpatialRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
10046 0 : jint jresult = 0 ;
10047 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10048 0 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
10049 : CPLErr result;
10050 :
10051 : (void)jenv;
10052 : (void)jcls;
10053 : (void)jarg1_;
10054 : (void)jarg2_;
10055 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10056 0 : arg2 = *(OSRSpatialReferenceShadow **)&jarg2;
10057 0 : result = (CPLErr)GDALDatasetShadow_SetSpatialRef(arg1,arg2);
10058 0 : jresult = (jint)result;
10059 0 : return jresult;
10060 : }
10061 :
10062 :
10063 6 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetGeoTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) {
10064 6 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10065 : double *arg2 ;
10066 :
10067 : (void)jenv;
10068 : (void)jcls;
10069 : (void)jarg1_;
10070 6 : arg1 = *(GDALDatasetShadow **)&jarg1;
10071 : {
10072 : /* %typemap(in) (double argout[ANY]) */
10073 6 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 6) {
10074 : char errorMsg[512];
10075 0 : sprintf(errorMsg, "array of size %d expected", 6);
10076 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
10077 0 : return ;
10078 : }
10079 6 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
10080 : }
10081 6 : GDALDatasetShadow_GetGeoTransform(arg1,arg2);
10082 : {
10083 : /* %typemap(argout) (double argout[ANY]) */
10084 : }
10085 : {
10086 : /* %typemap(freearg) (double argout[ANY]) */
10087 6 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
10088 : }
10089 : }
10090 :
10091 :
10092 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetGeoTransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) {
10093 0 : jint jresult = 0 ;
10094 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10095 : double *arg2 ;
10096 : CPLErr result;
10097 :
10098 : (void)jenv;
10099 : (void)jcls;
10100 : (void)jarg1_;
10101 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10102 : {
10103 : /* %typemap(in) (double argin[ANY]) */
10104 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 6) {
10105 : char errorMsg[512];
10106 0 : sprintf(errorMsg, "array of size %d expected", 6);
10107 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
10108 0 : return 0;
10109 : }
10110 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
10111 : }
10112 0 : result = (CPLErr)GDALDatasetShadow_SetGeoTransform(arg1,arg2);
10113 0 : jresult = (jint)result;
10114 : {
10115 : /* %typemap(argout) (double argin[ANY]) */
10116 : }
10117 : {
10118 : /* %typemap(freearg) (double argin[ANY]) */
10119 0 : if(arg2) {
10120 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, JNI_ABORT);
10121 : }
10122 : }
10123 0 : return jresult;
10124 : }
10125 :
10126 :
10127 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1BuildOverviews_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jintArray jarg3, jobject jarg5, jobject jarg7) {
10128 0 : jint jresult = 0 ;
10129 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10130 0 : char *arg2 = (char *) 0 ;
10131 : int arg3 ;
10132 0 : int *arg4 = (int *) 0 ;
10133 : GDALProgressFunc arg5 ;
10134 0 : void *arg6 = (void *) 0 ;
10135 0 : char **arg7 = (char **) 0 ;
10136 : int result;
10137 :
10138 : (void)jenv;
10139 : (void)jcls;
10140 : JavaProgressData sProgressInfo;
10141 0 : sProgressInfo.jenv = jenv;
10142 0 : sProgressInfo.pJavaCallback = NULL;
10143 : (void)jarg1_;
10144 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10145 : {
10146 : /* %typemap(in) (const char* stringWithDefaultValue) */
10147 0 : if (jarg2)
10148 : {
10149 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
10150 : }
10151 : }
10152 : {
10153 : /* %typemap(in) (int nList, int* pList) */
10154 : /* check if is List */
10155 0 : if (jarg3)
10156 : {
10157 0 : arg3 = jenv->GetArrayLength(jarg3);
10158 0 : if (arg3 == 0)
10159 0 : arg4 = NULL;
10160 : else
10161 0 : arg4 = (int *)jenv->GetIntArrayElements(jarg3, NULL);
10162 : }
10163 : else
10164 : {
10165 0 : arg3 = 0;
10166 0 : arg4 = NULL;
10167 : }
10168 : }
10169 : {
10170 0 : if ( jarg5 != 0 ) {
10171 0 : sProgressInfo.pJavaCallback = jarg5;
10172 0 : arg5 = JavaProgressProxy;
10173 0 : arg6 = &sProgressInfo;
10174 : }
10175 : else
10176 : {
10177 0 : arg5 = NULL;
10178 0 : arg6 = NULL;
10179 : }
10180 : }
10181 : {
10182 : /* %typemap(in) char **options */
10183 0 : arg7 = NULL;
10184 0 : if(jarg7 != 0) {
10185 0 : const jclass vector = jenv->FindClass("java/util/Vector");
10186 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
10187 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
10188 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
10189 : "()Ljava/util/Enumeration;");
10190 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
10191 : "hasMoreElements", "()Z");
10192 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
10193 : "nextElement", "()Ljava/lang/Object;");
10194 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
10195 0 : hasMoreElements == NULL || getNextElement == NULL) {
10196 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
10197 0 : return 0;
10198 : }
10199 0 : for (jobject keys = jenv->CallObjectMethod(jarg7, elements);
10200 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
10201 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
10202 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
10203 : {
10204 0 : CSLDestroy(arg7);
10205 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
10206 0 : return 0;
10207 : }
10208 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
10209 0 : arg7 = CSLAddString(arg7, valptr);
10210 0 : jenv->ReleaseStringUTFChars(value, valptr);
10211 : }
10212 : }
10213 : }
10214 0 : result = (int)GDALDatasetShadow_BuildOverviews__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7);
10215 0 : jresult = (jint)result;
10216 : {
10217 : /* %typemap(argout) (int nList, int* pList) */
10218 : }
10219 : {
10220 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
10221 0 : if (jarg2)
10222 : {
10223 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
10224 : }
10225 : }
10226 : {
10227 : /* %typemap(freearg) (int nList, int* pList) */
10228 0 : if (arg4) {
10229 0 : jenv->ReleaseIntArrayElements(jarg3, (jint*)arg4, JNI_ABORT);
10230 : }
10231 : }
10232 : {
10233 : /* %typemap(freearg) char **options */
10234 0 : CSLDestroy( arg7 );
10235 : }
10236 0 : return jresult;
10237 : }
10238 :
10239 :
10240 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1BuildOverviews_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jintArray jarg3, jobject jarg5) {
10241 1 : jint jresult = 0 ;
10242 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10243 1 : char *arg2 = (char *) 0 ;
10244 : int arg3 ;
10245 1 : int *arg4 = (int *) 0 ;
10246 : GDALProgressFunc arg5 ;
10247 1 : void *arg6 = (void *) 0 ;
10248 : int result;
10249 :
10250 : (void)jenv;
10251 : (void)jcls;
10252 : JavaProgressData sProgressInfo;
10253 1 : sProgressInfo.jenv = jenv;
10254 1 : sProgressInfo.pJavaCallback = NULL;
10255 : (void)jarg1_;
10256 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
10257 : {
10258 : /* %typemap(in) (const char* stringWithDefaultValue) */
10259 1 : if (jarg2)
10260 : {
10261 1 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
10262 : }
10263 : }
10264 : {
10265 : /* %typemap(in) (int nList, int* pList) */
10266 : /* check if is List */
10267 1 : if (jarg3)
10268 : {
10269 1 : arg3 = jenv->GetArrayLength(jarg3);
10270 1 : if (arg3 == 0)
10271 0 : arg4 = NULL;
10272 : else
10273 1 : arg4 = (int *)jenv->GetIntArrayElements(jarg3, NULL);
10274 : }
10275 : else
10276 : {
10277 0 : arg3 = 0;
10278 0 : arg4 = NULL;
10279 : }
10280 : }
10281 : {
10282 1 : if ( jarg5 != 0 ) {
10283 1 : sProgressInfo.pJavaCallback = jarg5;
10284 1 : arg5 = JavaProgressProxy;
10285 1 : arg6 = &sProgressInfo;
10286 : }
10287 : else
10288 : {
10289 0 : arg5 = NULL;
10290 0 : arg6 = NULL;
10291 : }
10292 : }
10293 1 : result = (int)GDALDatasetShadow_BuildOverviews__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
10294 1 : jresult = (jint)result;
10295 : {
10296 : /* %typemap(argout) (int nList, int* pList) */
10297 : }
10298 : {
10299 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
10300 1 : if (jarg2)
10301 : {
10302 1 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
10303 : }
10304 : }
10305 : {
10306 : /* %typemap(freearg) (int nList, int* pList) */
10307 1 : if (arg4) {
10308 1 : jenv->ReleaseIntArrayElements(jarg3, (jint*)arg4, JNI_ABORT);
10309 : }
10310 : }
10311 1 : return jresult;
10312 : }
10313 :
10314 :
10315 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1BuildOverviews_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jintArray jarg3) {
10316 0 : jint jresult = 0 ;
10317 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10318 0 : char *arg2 = (char *) 0 ;
10319 : int arg3 ;
10320 0 : int *arg4 = (int *) 0 ;
10321 : int result;
10322 :
10323 : (void)jenv;
10324 : (void)jcls;
10325 : (void)jarg1_;
10326 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10327 : {
10328 : /* %typemap(in) (const char* stringWithDefaultValue) */
10329 0 : if (jarg2)
10330 : {
10331 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
10332 : }
10333 : }
10334 : {
10335 : /* %typemap(in) (int nList, int* pList) */
10336 : /* check if is List */
10337 0 : if (jarg3)
10338 : {
10339 0 : arg3 = jenv->GetArrayLength(jarg3);
10340 0 : if (arg3 == 0)
10341 0 : arg4 = NULL;
10342 : else
10343 0 : arg4 = (int *)jenv->GetIntArrayElements(jarg3, NULL);
10344 : }
10345 : else
10346 : {
10347 0 : arg3 = 0;
10348 0 : arg4 = NULL;
10349 : }
10350 : }
10351 0 : result = (int)GDALDatasetShadow_BuildOverviews__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
10352 0 : jresult = (jint)result;
10353 : {
10354 : /* %typemap(argout) (int nList, int* pList) */
10355 : }
10356 : {
10357 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
10358 0 : if (jarg2)
10359 : {
10360 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
10361 : }
10362 : }
10363 : {
10364 : /* %typemap(freearg) (int nList, int* pList) */
10365 0 : if (arg4) {
10366 0 : jenv->ReleaseIntArrayElements(jarg3, (jint*)arg4, JNI_ABORT);
10367 : }
10368 : }
10369 0 : return jresult;
10370 : }
10371 :
10372 :
10373 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetGCPCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10374 1 : jint jresult = 0 ;
10375 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10376 : int result;
10377 :
10378 : (void)jenv;
10379 : (void)jcls;
10380 : (void)jarg1_;
10381 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
10382 1 : result = (int)GDALDatasetShadow_GetGCPCount(arg1);
10383 1 : jresult = (jint)result;
10384 1 : return jresult;
10385 : }
10386 :
10387 :
10388 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetGCPProjection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10389 0 : jstring jresult = 0 ;
10390 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10391 0 : char *result = 0 ;
10392 :
10393 : (void)jenv;
10394 : (void)jcls;
10395 : (void)jarg1_;
10396 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10397 0 : result = (char *)GDALDatasetShadow_GetGCPProjection(arg1);
10398 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
10399 0 : return jresult;
10400 : }
10401 :
10402 :
10403 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetGCPSpatialRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10404 0 : jlong jresult = 0 ;
10405 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10406 0 : OSRSpatialReferenceShadow *result = 0 ;
10407 :
10408 : (void)jenv;
10409 : (void)jcls;
10410 : (void)jarg1_;
10411 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10412 0 : result = (OSRSpatialReferenceShadow *)GDALDatasetShadow_GetGCPSpatialRef(arg1);
10413 0 : *(OSRSpatialReferenceShadow **)&jresult = result;
10414 0 : return jresult;
10415 : }
10416 :
10417 :
10418 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetGCPs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
10419 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10420 0 : int *arg2 = (int *) 0 ;
10421 0 : GDAL_GCP **arg3 = (GDAL_GCP **) 0 ;
10422 0 : int nGCPs2 = 0 ;
10423 0 : GDAL_GCP *pGCPs2 = 0 ;
10424 :
10425 : (void)jenv;
10426 : (void)jcls;
10427 : (void)jarg1_;
10428 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10429 : {
10430 : /* %typemap(in, numinputs=1) (int *nGCPs2, GDAL_GCP const **pGCPs2 ) */
10431 0 : arg2 = &nGCPs2;
10432 0 : arg3 = &pGCPs2;
10433 : }
10434 0 : GDALDatasetShadow_GetGCPs(arg1,arg2,(GDAL_GCP const **)arg3);
10435 : {
10436 : /* %typemap(argout) (int *nGCPs, GDAL_GCP const **pGCPs ) */
10437 0 : const jclass GCPClass = jenv->FindClass("org/gdal/gdal/GCP");
10438 0 : const jclass vectorClass = jenv->FindClass("java/util/Vector");
10439 0 : const jmethodID add = jenv->GetMethodID(vectorClass, "add", "(Ljava/lang/Object;)Z");
10440 0 : const jmethodID GCPcon = jenv->GetMethodID(GCPClass, "<init>",
10441 : "(DDDDDLjava/lang/String;Ljava/lang/String;)V");
10442 :
10443 : int i;
10444 0 : for (i=0; i<*arg2; i++ ) {
10445 0 : jstring stringInfo = jenv->NewStringUTF((*arg3)[i].pszInfo);
10446 0 : jstring stringId = jenv->NewStringUTF((*arg3)[i].pszId);
10447 0 : jobject GCPobj = jenv->NewObject(GCPClass, GCPcon,
10448 0 : (*arg3)[i].dfGCPX,
10449 0 : (*arg3)[i].dfGCPY,
10450 0 : (*arg3)[i].dfGCPZ,
10451 0 : (*arg3)[i].dfGCPPixel,
10452 0 : (*arg3)[i].dfGCPLine,
10453 : stringInfo,
10454 : stringId);
10455 0 : jenv->DeleteLocalRef(stringInfo);
10456 0 : jenv->DeleteLocalRef(stringId);
10457 0 : jenv->CallBooleanMethod(jarg2, add, GCPobj);
10458 : }
10459 : }
10460 0 : }
10461 :
10462 :
10463 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetGCPs(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jstring jarg4) {
10464 0 : jint jresult = 0 ;
10465 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10466 : int arg2 ;
10467 0 : GDAL_GCP *arg3 = (GDAL_GCP *) 0 ;
10468 0 : char *arg4 = (char *) 0 ;
10469 : CPLErr result;
10470 :
10471 : (void)jenv;
10472 : (void)jcls;
10473 : (void)jarg1_;
10474 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10475 : {
10476 : /* %typemap(in, numinputs=1) (int nGCPs, GDAL_GCP const * pGCPs) */
10477 0 : if (jarg2)
10478 : {
10479 0 : arg2 = jenv->GetArrayLength(jarg2);
10480 0 : if (arg2 == 0)
10481 0 : arg3 = NULL;
10482 : else
10483 : {
10484 0 : arg3 = (GDAL_GCP*) malloc(sizeof(GDAL_GCP) * arg2);
10485 : int i;
10486 0 : for (i=0; i<arg2; i++) {
10487 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
10488 0 : if (obj == NULL)
10489 : {
10490 0 : free (arg3 );
10491 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
10492 0 : return 0;
10493 : }
10494 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/GCP");
10495 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/GCP;)J");
10496 0 : arg3[i] = *(GDAL_GCP*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
10497 : }
10498 : }
10499 : }
10500 : else
10501 : {
10502 0 : arg2 = 0;
10503 0 : arg3 = NULL;
10504 : }
10505 : }
10506 0 : arg4 = 0;
10507 0 : if (jarg4) {
10508 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
10509 0 : if (!arg4) return 0;
10510 : }
10511 0 : result = (CPLErr)GDALDatasetShadow_SetGCPs(arg1,arg2,(GDAL_GCP const *)arg3,(char const *)arg4);
10512 0 : jresult = (jint)result;
10513 : {
10514 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const * pGCPs) */
10515 0 : if (arg3) {
10516 0 : free((void*) arg3);
10517 : }
10518 : }
10519 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
10520 0 : return jresult;
10521 : }
10522 :
10523 :
10524 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetGCPs2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jlong jarg4, jobject jarg4_) {
10525 0 : jint jresult = 0 ;
10526 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10527 : int arg2 ;
10528 0 : GDAL_GCP *arg3 = (GDAL_GCP *) 0 ;
10529 0 : OSRSpatialReferenceShadow *arg4 = (OSRSpatialReferenceShadow *) 0 ;
10530 : CPLErr result;
10531 :
10532 : (void)jenv;
10533 : (void)jcls;
10534 : (void)jarg1_;
10535 : (void)jarg4_;
10536 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10537 : {
10538 : /* %typemap(in, numinputs=1) (int nGCPs, GDAL_GCP const * pGCPs) */
10539 0 : if (jarg2)
10540 : {
10541 0 : arg2 = jenv->GetArrayLength(jarg2);
10542 0 : if (arg2 == 0)
10543 0 : arg3 = NULL;
10544 : else
10545 : {
10546 0 : arg3 = (GDAL_GCP*) malloc(sizeof(GDAL_GCP) * arg2);
10547 : int i;
10548 0 : for (i=0; i<arg2; i++) {
10549 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
10550 0 : if (obj == NULL)
10551 : {
10552 0 : free (arg3 );
10553 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
10554 0 : return 0;
10555 : }
10556 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/GCP");
10557 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/GCP;)J");
10558 0 : arg3[i] = *(GDAL_GCP*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
10559 : }
10560 : }
10561 : }
10562 : else
10563 : {
10564 0 : arg2 = 0;
10565 0 : arg3 = NULL;
10566 : }
10567 : }
10568 0 : arg4 = *(OSRSpatialReferenceShadow **)&jarg4;
10569 0 : result = (CPLErr)GDALDatasetShadow_SetGCPs2(arg1,arg2,(GDAL_GCP const *)arg3,arg4);
10570 0 : jresult = (jint)result;
10571 : {
10572 : /* %typemap(freearg) (int nGCPs, GDAL_GCP const * pGCPs) */
10573 0 : if (arg3) {
10574 0 : free((void*) arg3);
10575 : }
10576 : }
10577 0 : return jresult;
10578 : }
10579 :
10580 :
10581 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1FlushCache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10582 0 : jint jresult = 0 ;
10583 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10584 : CPLErr result;
10585 :
10586 : (void)jenv;
10587 : (void)jcls;
10588 : (void)jarg1_;
10589 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10590 0 : result = (CPLErr)GDALDatasetShadow_FlushCache(arg1);
10591 0 : jresult = (jint)result;
10592 0 : return jresult;
10593 : }
10594 :
10595 :
10596 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AddBand_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3) {
10597 0 : jint jresult = 0 ;
10598 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10599 : GDALDataType arg2 ;
10600 0 : char **arg3 = (char **) 0 ;
10601 : CPLErr result;
10602 :
10603 : (void)jenv;
10604 : (void)jcls;
10605 : (void)jarg1_;
10606 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10607 0 : arg2 = (GDALDataType)jarg2;
10608 : {
10609 : /* %typemap(in) char **options */
10610 0 : arg3 = NULL;
10611 0 : if(jarg3 != 0) {
10612 0 : const jclass vector = jenv->FindClass("java/util/Vector");
10613 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
10614 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
10615 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
10616 : "()Ljava/util/Enumeration;");
10617 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
10618 : "hasMoreElements", "()Z");
10619 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
10620 : "nextElement", "()Ljava/lang/Object;");
10621 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
10622 0 : hasMoreElements == NULL || getNextElement == NULL) {
10623 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
10624 0 : return 0;
10625 : }
10626 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
10627 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
10628 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
10629 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
10630 : {
10631 0 : CSLDestroy(arg3);
10632 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
10633 0 : return 0;
10634 : }
10635 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
10636 0 : arg3 = CSLAddString(arg3, valptr);
10637 0 : jenv->ReleaseStringUTFChars(value, valptr);
10638 : }
10639 : }
10640 : }
10641 0 : result = (CPLErr)GDALDatasetShadow_AddBand__SWIG_0(arg1,arg2,arg3);
10642 0 : jresult = (jint)result;
10643 : {
10644 : /* %typemap(freearg) char **options */
10645 0 : CSLDestroy( arg3 );
10646 : }
10647 0 : return jresult;
10648 : }
10649 :
10650 :
10651 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AddBand_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
10652 0 : jint jresult = 0 ;
10653 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10654 : GDALDataType arg2 ;
10655 : CPLErr result;
10656 :
10657 : (void)jenv;
10658 : (void)jcls;
10659 : (void)jarg1_;
10660 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10661 0 : arg2 = (GDALDataType)jarg2;
10662 0 : result = (CPLErr)GDALDatasetShadow_AddBand__SWIG_0(arg1,arg2);
10663 0 : jresult = (jint)result;
10664 0 : return jresult;
10665 : }
10666 :
10667 :
10668 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AddBand_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10669 0 : jint jresult = 0 ;
10670 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10671 : CPLErr result;
10672 :
10673 : (void)jenv;
10674 : (void)jcls;
10675 : (void)jarg1_;
10676 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10677 0 : result = (CPLErr)GDALDatasetShadow_AddBand__SWIG_0(arg1);
10678 0 : jresult = (jint)result;
10679 0 : return jresult;
10680 : }
10681 :
10682 :
10683 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateMaskBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
10684 0 : jint jresult = 0 ;
10685 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10686 : int arg2 ;
10687 : CPLErr result;
10688 :
10689 : (void)jenv;
10690 : (void)jcls;
10691 : (void)jarg1_;
10692 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10693 0 : arg2 = (int)jarg2;
10694 0 : result = (CPLErr)GDALDatasetShadow_CreateMaskBand(arg1,arg2);
10695 0 : jresult = (jint)result;
10696 0 : return jresult;
10697 : }
10698 :
10699 :
10700 1 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetFileList(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
10701 1 : jobject jresult = 0 ;
10702 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10703 1 : char **result = 0 ;
10704 :
10705 : (void)jenv;
10706 : (void)jcls;
10707 : (void)jarg1_;
10708 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
10709 1 : result = (char **)GDALDatasetShadow_GetFileList(arg1);
10710 : {
10711 : /* %typemap(out) char **CSL */
10712 1 : char **stringarray = result;
10713 1 : const jclass vector = jenv->FindClass("java/util/Vector");
10714 1 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
10715 1 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
10716 :
10717 1 : jresult = jenv->NewObject(vector, constructor);
10718 1 : if ( stringarray != NULL ) {
10719 2 : while(*stringarray != NULL) {
10720 : /*printf("working on string %s\n", *stringarray);*/
10721 1 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
10722 1 : jenv->CallBooleanMethod(jresult, add, value);
10723 1 : jenv->DeleteLocalRef(value);
10724 1 : stringarray++;
10725 : }
10726 : }
10727 1 : CSLDestroy(result);
10728 : }
10729 1 : return jresult;
10730 : }
10731 :
10732 :
10733 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jintArray jarg9, jobject jarg11) {
10734 0 : jint jresult = 0 ;
10735 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10736 : int arg2 ;
10737 : int arg3 ;
10738 : int arg4 ;
10739 : int arg5 ;
10740 0 : int *arg6 = (int *) 0 ;
10741 0 : int *arg7 = (int *) 0 ;
10742 0 : GDALDataType *arg8 = (GDALDataType *) 0 ;
10743 : int arg9 ;
10744 0 : int *arg10 = (int *) 0 ;
10745 0 : char **arg11 = (char **) 0 ;
10746 : CPLErr result;
10747 :
10748 : (void)jenv;
10749 : (void)jcls;
10750 : (void)jarg1_;
10751 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10752 0 : arg2 = (int)jarg2;
10753 0 : arg3 = (int)jarg3;
10754 0 : arg4 = (int)jarg4;
10755 0 : arg5 = (int)jarg5;
10756 0 : arg6 = *(int **)&jarg6;
10757 0 : arg7 = *(int **)&jarg7;
10758 0 : arg8 = *(GDALDataType **)&jarg8;
10759 : {
10760 : /* %typemap(in) (int nList, int* pList) */
10761 : /* check if is List */
10762 0 : if (jarg9)
10763 : {
10764 0 : arg9 = jenv->GetArrayLength(jarg9);
10765 0 : if (arg9 == 0)
10766 0 : arg10 = NULL;
10767 : else
10768 0 : arg10 = (int *)jenv->GetIntArrayElements(jarg9, NULL);
10769 : }
10770 : else
10771 : {
10772 0 : arg9 = 0;
10773 0 : arg10 = NULL;
10774 : }
10775 : }
10776 : {
10777 : /* %typemap(in) char **options */
10778 0 : arg11 = NULL;
10779 0 : if(jarg11 != 0) {
10780 0 : const jclass vector = jenv->FindClass("java/util/Vector");
10781 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
10782 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
10783 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
10784 : "()Ljava/util/Enumeration;");
10785 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
10786 : "hasMoreElements", "()Z");
10787 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
10788 : "nextElement", "()Ljava/lang/Object;");
10789 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
10790 0 : hasMoreElements == NULL || getNextElement == NULL) {
10791 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
10792 0 : return 0;
10793 : }
10794 0 : for (jobject keys = jenv->CallObjectMethod(jarg11, elements);
10795 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
10796 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
10797 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
10798 : {
10799 0 : CSLDestroy(arg11);
10800 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
10801 0 : return 0;
10802 : }
10803 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
10804 0 : arg11 = CSLAddString(arg11, valptr);
10805 0 : jenv->ReleaseStringUTFChars(value, valptr);
10806 : }
10807 : }
10808 : }
10809 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
10810 0 : jresult = (jint)result;
10811 : {
10812 : /* %typemap(argout) (int nList, int* pList) */
10813 : }
10814 : {
10815 : /* %typemap(freearg) (int nList, int* pList) */
10816 0 : if (arg10) {
10817 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*)arg10, JNI_ABORT);
10818 : }
10819 : }
10820 : {
10821 : /* %typemap(freearg) char **options */
10822 0 : CSLDestroy( arg11 );
10823 : }
10824 0 : return jresult;
10825 : }
10826 :
10827 :
10828 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jintArray jarg9) {
10829 0 : jint jresult = 0 ;
10830 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10831 : int arg2 ;
10832 : int arg3 ;
10833 : int arg4 ;
10834 : int arg5 ;
10835 0 : int *arg6 = (int *) 0 ;
10836 0 : int *arg7 = (int *) 0 ;
10837 0 : GDALDataType *arg8 = (GDALDataType *) 0 ;
10838 : int arg9 ;
10839 0 : int *arg10 = (int *) 0 ;
10840 : CPLErr result;
10841 :
10842 : (void)jenv;
10843 : (void)jcls;
10844 : (void)jarg1_;
10845 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10846 0 : arg2 = (int)jarg2;
10847 0 : arg3 = (int)jarg3;
10848 0 : arg4 = (int)jarg4;
10849 0 : arg5 = (int)jarg5;
10850 0 : arg6 = *(int **)&jarg6;
10851 0 : arg7 = *(int **)&jarg7;
10852 0 : arg8 = *(GDALDataType **)&jarg8;
10853 : {
10854 : /* %typemap(in) (int nList, int* pList) */
10855 : /* check if is List */
10856 0 : if (jarg9)
10857 : {
10858 0 : arg9 = jenv->GetArrayLength(jarg9);
10859 0 : if (arg9 == 0)
10860 0 : arg10 = NULL;
10861 : else
10862 0 : arg10 = (int *)jenv->GetIntArrayElements(jarg9, NULL);
10863 : }
10864 : else
10865 : {
10866 0 : arg9 = 0;
10867 0 : arg10 = NULL;
10868 : }
10869 : }
10870 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
10871 0 : jresult = (jint)result;
10872 : {
10873 : /* %typemap(argout) (int nList, int* pList) */
10874 : }
10875 : {
10876 : /* %typemap(freearg) (int nList, int* pList) */
10877 0 : if (arg10) {
10878 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*)arg10, JNI_ABORT);
10879 : }
10880 : }
10881 0 : return jresult;
10882 : }
10883 :
10884 :
10885 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8) {
10886 0 : jint jresult = 0 ;
10887 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10888 : int arg2 ;
10889 : int arg3 ;
10890 : int arg4 ;
10891 : int arg5 ;
10892 0 : int *arg6 = (int *) 0 ;
10893 0 : int *arg7 = (int *) 0 ;
10894 0 : GDALDataType *arg8 = (GDALDataType *) 0 ;
10895 : CPLErr result;
10896 :
10897 : (void)jenv;
10898 : (void)jcls;
10899 : (void)jarg1_;
10900 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10901 0 : arg2 = (int)jarg2;
10902 0 : arg3 = (int)jarg3;
10903 0 : arg4 = (int)jarg4;
10904 0 : arg5 = (int)jarg5;
10905 0 : arg6 = *(int **)&jarg6;
10906 0 : arg7 = *(int **)&jarg7;
10907 0 : arg8 = *(GDALDataType **)&jarg8;
10908 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
10909 0 : jresult = (jint)result;
10910 0 : return jresult;
10911 : }
10912 :
10913 :
10914 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7) {
10915 0 : jint jresult = 0 ;
10916 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10917 : int arg2 ;
10918 : int arg3 ;
10919 : int arg4 ;
10920 : int arg5 ;
10921 0 : int *arg6 = (int *) 0 ;
10922 0 : int *arg7 = (int *) 0 ;
10923 : CPLErr result;
10924 :
10925 : (void)jenv;
10926 : (void)jcls;
10927 : (void)jarg1_;
10928 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10929 0 : arg2 = (int)jarg2;
10930 0 : arg3 = (int)jarg3;
10931 0 : arg4 = (int)jarg4;
10932 0 : arg5 = (int)jarg5;
10933 0 : arg6 = *(int **)&jarg6;
10934 0 : arg7 = *(int **)&jarg7;
10935 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
10936 0 : jresult = (jint)result;
10937 0 : return jresult;
10938 : }
10939 :
10940 :
10941 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6) {
10942 0 : jint jresult = 0 ;
10943 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10944 : int arg2 ;
10945 : int arg3 ;
10946 : int arg4 ;
10947 : int arg5 ;
10948 0 : int *arg6 = (int *) 0 ;
10949 : CPLErr result;
10950 :
10951 : (void)jenv;
10952 : (void)jcls;
10953 : (void)jarg1_;
10954 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10955 0 : arg2 = (int)jarg2;
10956 0 : arg3 = (int)jarg3;
10957 0 : arg4 = (int)jarg4;
10958 0 : arg5 = (int)jarg5;
10959 0 : arg6 = *(int **)&jarg6;
10960 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
10961 0 : jresult = (jint)result;
10962 0 : return jresult;
10963 : }
10964 :
10965 :
10966 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AdviseRead_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5) {
10967 0 : jint jresult = 0 ;
10968 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10969 : int arg2 ;
10970 : int arg3 ;
10971 : int arg4 ;
10972 : int arg5 ;
10973 : CPLErr result;
10974 :
10975 : (void)jenv;
10976 : (void)jcls;
10977 : (void)jarg1_;
10978 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
10979 0 : arg2 = (int)jarg2;
10980 0 : arg3 = (int)jarg3;
10981 0 : arg4 = (int)jarg4;
10982 0 : arg5 = (int)jarg5;
10983 0 : result = (CPLErr)GDALDatasetShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5);
10984 0 : jresult = (jint)result;
10985 0 : return jresult;
10986 : }
10987 :
10988 :
10989 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5) {
10990 0 : jlong jresult = 0 ;
10991 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
10992 0 : char *arg2 = (char *) 0 ;
10993 0 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
10994 : OGRwkbGeometryType arg4 ;
10995 0 : char **arg5 = (char **) 0 ;
10996 0 : OGRLayerShadow *result = 0 ;
10997 :
10998 : (void)jenv;
10999 : (void)jcls;
11000 : (void)jarg1_;
11001 : (void)jarg3_;
11002 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11003 0 : arg2 = 0;
11004 0 : if (jarg2) {
11005 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11006 0 : if (!arg2) return 0;
11007 : }
11008 0 : arg3 = *(OSRSpatialReferenceShadow **)&jarg3;
11009 0 : arg4 = (OGRwkbGeometryType)jarg4;
11010 : {
11011 : /* %typemap(in) char **options */
11012 0 : arg5 = NULL;
11013 0 : if(jarg5 != 0) {
11014 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11015 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
11016 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
11017 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
11018 : "()Ljava/util/Enumeration;");
11019 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
11020 : "hasMoreElements", "()Z");
11021 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
11022 : "nextElement", "()Ljava/lang/Object;");
11023 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
11024 0 : hasMoreElements == NULL || getNextElement == NULL) {
11025 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
11026 0 : return 0;
11027 : }
11028 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
11029 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
11030 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
11031 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
11032 : {
11033 0 : CSLDestroy(arg5);
11034 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
11035 0 : return 0;
11036 : }
11037 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
11038 0 : arg5 = CSLAddString(arg5, valptr);
11039 0 : jenv->ReleaseStringUTFChars(value, valptr);
11040 : }
11041 : }
11042 : }
11043 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
11044 0 : *(OGRLayerShadow **)&jresult = result;
11045 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11046 : {
11047 : /* %typemap(freearg) char **options */
11048 0 : CSLDestroy( arg5 );
11049 : }
11050 0 : return jresult;
11051 : }
11052 :
11053 :
11054 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4) {
11055 0 : jlong jresult = 0 ;
11056 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11057 0 : char *arg2 = (char *) 0 ;
11058 0 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
11059 : OGRwkbGeometryType arg4 ;
11060 0 : OGRLayerShadow *result = 0 ;
11061 :
11062 : (void)jenv;
11063 : (void)jcls;
11064 : (void)jarg1_;
11065 : (void)jarg3_;
11066 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11067 0 : arg2 = 0;
11068 0 : if (jarg2) {
11069 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11070 0 : if (!arg2) return 0;
11071 : }
11072 0 : arg3 = *(OSRSpatialReferenceShadow **)&jarg3;
11073 0 : arg4 = (OGRwkbGeometryType)jarg4;
11074 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
11075 0 : *(OGRLayerShadow **)&jresult = result;
11076 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11077 0 : return jresult;
11078 : }
11079 :
11080 :
11081 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayer_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
11082 0 : jlong jresult = 0 ;
11083 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11084 0 : char *arg2 = (char *) 0 ;
11085 0 : OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
11086 0 : OGRLayerShadow *result = 0 ;
11087 :
11088 : (void)jenv;
11089 : (void)jcls;
11090 : (void)jarg1_;
11091 : (void)jarg3_;
11092 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11093 0 : arg2 = 0;
11094 0 : if (jarg2) {
11095 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11096 0 : if (!arg2) return 0;
11097 : }
11098 0 : arg3 = *(OSRSpatialReferenceShadow **)&jarg3;
11099 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3);
11100 0 : *(OGRLayerShadow **)&jresult = result;
11101 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11102 0 : return jresult;
11103 : }
11104 :
11105 :
11106 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayer_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11107 0 : jlong jresult = 0 ;
11108 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11109 0 : char *arg2 = (char *) 0 ;
11110 0 : OGRLayerShadow *result = 0 ;
11111 :
11112 : (void)jenv;
11113 : (void)jcls;
11114 : (void)jarg1_;
11115 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11116 0 : arg2 = 0;
11117 0 : if (jarg2) {
11118 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11119 0 : if (!arg2) return 0;
11120 : }
11121 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2);
11122 0 : *(OGRLayerShadow **)&jresult = result;
11123 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11124 0 : return jresult;
11125 : }
11126 :
11127 :
11128 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayerFromGeomFieldDefn_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jobject jarg4) {
11129 0 : jlong jresult = 0 ;
11130 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11131 0 : char *arg2 = (char *) 0 ;
11132 0 : OGRGeomFieldDefnShadow *arg3 = (OGRGeomFieldDefnShadow *) 0 ;
11133 0 : char **arg4 = (char **) 0 ;
11134 0 : OGRLayerShadow *result = 0 ;
11135 :
11136 : (void)jenv;
11137 : (void)jcls;
11138 : (void)jarg1_;
11139 : (void)jarg3_;
11140 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11141 0 : arg2 = 0;
11142 0 : if (jarg2) {
11143 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11144 0 : if (!arg2) return 0;
11145 : }
11146 0 : arg3 = *(OGRGeomFieldDefnShadow **)&jarg3;
11147 : {
11148 : /* %typemap(in) char **options */
11149 0 : arg4 = NULL;
11150 0 : if(jarg4 != 0) {
11151 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11152 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
11153 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
11154 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
11155 : "()Ljava/util/Enumeration;");
11156 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
11157 : "hasMoreElements", "()Z");
11158 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
11159 : "nextElement", "()Ljava/lang/Object;");
11160 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
11161 0 : hasMoreElements == NULL || getNextElement == NULL) {
11162 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
11163 0 : return 0;
11164 : }
11165 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
11166 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
11167 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
11168 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
11169 : {
11170 0 : CSLDestroy(arg4);
11171 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
11172 0 : return 0;
11173 : }
11174 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
11175 0 : arg4 = CSLAddString(arg4, valptr);
11176 0 : jenv->ReleaseStringUTFChars(value, valptr);
11177 : }
11178 : }
11179 : }
11180 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayerFromGeomFieldDefn__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
11181 0 : *(OGRLayerShadow **)&jresult = result;
11182 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11183 : {
11184 : /* %typemap(freearg) char **options */
11185 0 : CSLDestroy( arg4 );
11186 : }
11187 0 : return jresult;
11188 : }
11189 :
11190 :
11191 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CreateLayerFromGeomFieldDefn_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
11192 0 : jlong jresult = 0 ;
11193 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11194 0 : char *arg2 = (char *) 0 ;
11195 0 : OGRGeomFieldDefnShadow *arg3 = (OGRGeomFieldDefnShadow *) 0 ;
11196 0 : OGRLayerShadow *result = 0 ;
11197 :
11198 : (void)jenv;
11199 : (void)jcls;
11200 : (void)jarg1_;
11201 : (void)jarg3_;
11202 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11203 0 : arg2 = 0;
11204 0 : if (jarg2) {
11205 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11206 0 : if (!arg2) return 0;
11207 : }
11208 0 : arg3 = *(OGRGeomFieldDefnShadow **)&jarg3;
11209 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CreateLayerFromGeomFieldDefn__SWIG_0(arg1,(char const *)arg2,arg3);
11210 0 : *(OGRLayerShadow **)&jresult = result;
11211 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11212 0 : return jresult;
11213 : }
11214 :
11215 :
11216 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CopyLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jobject jarg4) {
11217 0 : jlong jresult = 0 ;
11218 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11219 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11220 0 : char *arg3 = (char *) 0 ;
11221 0 : char **arg4 = (char **) 0 ;
11222 0 : OGRLayerShadow *result = 0 ;
11223 :
11224 : (void)jenv;
11225 : (void)jcls;
11226 : (void)jarg1_;
11227 : (void)jarg2_;
11228 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11229 0 : arg2 = *(OGRLayerShadow **)&jarg2;
11230 0 : arg3 = 0;
11231 0 : if (jarg3) {
11232 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
11233 0 : if (!arg3) return 0;
11234 : }
11235 : {
11236 : /* %typemap(in) char **options */
11237 0 : arg4 = NULL;
11238 0 : if(jarg4 != 0) {
11239 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11240 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
11241 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
11242 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
11243 : "()Ljava/util/Enumeration;");
11244 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
11245 : "hasMoreElements", "()Z");
11246 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
11247 : "nextElement", "()Ljava/lang/Object;");
11248 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
11249 0 : hasMoreElements == NULL || getNextElement == NULL) {
11250 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
11251 0 : return 0;
11252 : }
11253 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
11254 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
11255 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
11256 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
11257 : {
11258 0 : CSLDestroy(arg4);
11259 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
11260 0 : return 0;
11261 : }
11262 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
11263 0 : arg4 = CSLAddString(arg4, valptr);
11264 0 : jenv->ReleaseStringUTFChars(value, valptr);
11265 : }
11266 : }
11267 : }
11268 : {
11269 0 : if (!arg2) {
11270 : {
11271 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11272 : };
11273 : }
11274 : }
11275 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CopyLayer__SWIG_0(arg1,arg2,(char const *)arg3,arg4);
11276 0 : *(OGRLayerShadow **)&jresult = result;
11277 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
11278 : {
11279 : /* %typemap(freearg) char **options */
11280 0 : CSLDestroy( arg4 );
11281 : }
11282 0 : return jresult;
11283 : }
11284 :
11285 :
11286 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CopyLayer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) {
11287 0 : jlong jresult = 0 ;
11288 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11289 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11290 0 : char *arg3 = (char *) 0 ;
11291 0 : OGRLayerShadow *result = 0 ;
11292 :
11293 : (void)jenv;
11294 : (void)jcls;
11295 : (void)jarg1_;
11296 : (void)jarg2_;
11297 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11298 0 : arg2 = *(OGRLayerShadow **)&jarg2;
11299 0 : arg3 = 0;
11300 0 : if (jarg3) {
11301 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
11302 0 : if (!arg3) return 0;
11303 : }
11304 : {
11305 0 : if (!arg2) {
11306 : {
11307 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11308 : };
11309 : }
11310 : }
11311 0 : result = (OGRLayerShadow *)GDALDatasetShadow_CopyLayer__SWIG_0(arg1,arg2,(char const *)arg3);
11312 0 : *(OGRLayerShadow **)&jresult = result;
11313 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
11314 0 : return jresult;
11315 : }
11316 :
11317 :
11318 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1DeleteLayer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
11319 0 : jint jresult = 0 ;
11320 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11321 : int arg2 ;
11322 : OGRErr result;
11323 :
11324 : (void)jenv;
11325 : (void)jcls;
11326 : (void)jarg1_;
11327 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11328 0 : arg2 = (int)jarg2;
11329 0 : result = (OGRErr)GDALDatasetShadow_DeleteLayer(arg1,arg2);
11330 : {
11331 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11332 0 : if (result != 0 && bUseExceptions) {
11333 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11334 : OGRErrMessages(result));
11335 0 : return 0;
11336 : }
11337 0 : jresult = (jint)result;
11338 : }
11339 : {
11340 : /* %typemap(ret) OGRErr */
11341 : }
11342 0 : return jresult;
11343 : }
11344 :
11345 :
11346 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1IsLayerPrivate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
11347 0 : jboolean jresult = 0 ;
11348 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11349 : int arg2 ;
11350 : bool result;
11351 :
11352 : (void)jenv;
11353 : (void)jcls;
11354 : (void)jarg1_;
11355 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11356 0 : arg2 = (int)jarg2;
11357 0 : result = (bool)GDALDatasetShadow_IsLayerPrivate(arg1,arg2);
11358 0 : jresult = (jboolean)result;
11359 0 : return jresult;
11360 : }
11361 :
11362 :
11363 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetNextFeature(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11364 0 : jlong jresult = 0 ;
11365 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11366 0 : OGRFeatureShadow *result = 0 ;
11367 :
11368 : (void)jenv;
11369 : (void)jcls;
11370 : (void)jarg1_;
11371 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11372 0 : result = (OGRFeatureShadow *)GDALDatasetShadow_GetNextFeature(arg1);
11373 0 : *(OGRFeatureShadow **)&jresult = result;
11374 0 : return jresult;
11375 : }
11376 :
11377 :
11378 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1TestCapability(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11379 0 : jboolean jresult = 0 ;
11380 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11381 0 : char *arg2 = (char *) 0 ;
11382 : bool result;
11383 :
11384 : (void)jenv;
11385 : (void)jcls;
11386 : (void)jarg1_;
11387 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11388 0 : arg2 = 0;
11389 0 : if (jarg2) {
11390 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11391 0 : if (!arg2) return 0;
11392 : }
11393 0 : result = (bool)GDALDatasetShadow_TestCapability(arg1,(char const *)arg2);
11394 0 : jresult = (jboolean)result;
11395 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11396 0 : return jresult;
11397 : }
11398 :
11399 :
11400 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ExecuteSQL_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jstring jarg4) {
11401 0 : jlong jresult = 0 ;
11402 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11403 0 : char *arg2 = (char *) 0 ;
11404 0 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
11405 0 : char *arg4 = (char *) 0 ;
11406 0 : OGRLayerShadow *result = 0 ;
11407 :
11408 : (void)jenv;
11409 : (void)jcls;
11410 : (void)jarg1_;
11411 : (void)jarg3_;
11412 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11413 0 : arg2 = 0;
11414 0 : if (jarg2) {
11415 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11416 0 : if (!arg2) return 0;
11417 : }
11418 0 : arg3 = *(OGRGeometryShadow **)&jarg3;
11419 0 : arg4 = 0;
11420 0 : if (jarg4) {
11421 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
11422 0 : if (!arg4) return 0;
11423 : }
11424 : {
11425 0 : if (!arg2) {
11426 : {
11427 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11428 : };
11429 : }
11430 : }
11431 0 : result = (OGRLayerShadow *)GDALDatasetShadow_ExecuteSQL__SWIG_0(arg1,(char const *)arg2,arg3,(char const *)arg4);
11432 0 : *(OGRLayerShadow **)&jresult = result;
11433 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11434 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
11435 0 : return jresult;
11436 : }
11437 :
11438 :
11439 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ExecuteSQL_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
11440 0 : jlong jresult = 0 ;
11441 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11442 0 : char *arg2 = (char *) 0 ;
11443 0 : OGRGeometryShadow *arg3 = (OGRGeometryShadow *) 0 ;
11444 0 : OGRLayerShadow *result = 0 ;
11445 :
11446 : (void)jenv;
11447 : (void)jcls;
11448 : (void)jarg1_;
11449 : (void)jarg3_;
11450 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11451 0 : arg2 = 0;
11452 0 : if (jarg2) {
11453 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11454 0 : if (!arg2) return 0;
11455 : }
11456 0 : arg3 = *(OGRGeometryShadow **)&jarg3;
11457 : {
11458 0 : if (!arg2) {
11459 : {
11460 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11461 : };
11462 : }
11463 : }
11464 0 : result = (OGRLayerShadow *)GDALDatasetShadow_ExecuteSQL__SWIG_0(arg1,(char const *)arg2,arg3);
11465 0 : *(OGRLayerShadow **)&jresult = result;
11466 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11467 0 : return jresult;
11468 : }
11469 :
11470 :
11471 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ExecuteSQL_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11472 0 : jlong jresult = 0 ;
11473 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11474 0 : char *arg2 = (char *) 0 ;
11475 0 : OGRLayerShadow *result = 0 ;
11476 :
11477 : (void)jenv;
11478 : (void)jcls;
11479 : (void)jarg1_;
11480 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11481 0 : arg2 = 0;
11482 0 : if (jarg2) {
11483 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11484 0 : if (!arg2) return 0;
11485 : }
11486 : {
11487 0 : if (!arg2) {
11488 : {
11489 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11490 : };
11491 : }
11492 : }
11493 0 : result = (OGRLayerShadow *)GDALDatasetShadow_ExecuteSQL__SWIG_0(arg1,(char const *)arg2);
11494 0 : *(OGRLayerShadow **)&jresult = result;
11495 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11496 0 : return jresult;
11497 : }
11498 :
11499 :
11500 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReleaseResultSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
11501 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11502 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
11503 :
11504 : (void)jenv;
11505 : (void)jcls;
11506 : (void)jarg1_;
11507 : (void)jarg2_;
11508 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11509 0 : arg2 = *(OGRLayerShadow **)&jarg2;
11510 0 : GDALDatasetShadow_ReleaseResultSet(arg1,arg2);
11511 0 : }
11512 :
11513 :
11514 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetStyleTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11515 0 : jlong jresult = 0 ;
11516 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11517 0 : OGRStyleTableShadow *result = 0 ;
11518 :
11519 : (void)jenv;
11520 : (void)jcls;
11521 : (void)jarg1_;
11522 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11523 0 : result = (OGRStyleTableShadow *)GDALDatasetShadow_GetStyleTable(arg1);
11524 0 : *(OGRStyleTableShadow **)&jresult = result;
11525 0 : return jresult;
11526 : }
11527 :
11528 :
11529 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SetStyleTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
11530 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11531 0 : OGRStyleTableShadow *arg2 = (OGRStyleTableShadow *) 0 ;
11532 :
11533 : (void)jenv;
11534 : (void)jcls;
11535 : (void)jarg1_;
11536 : (void)jarg2_;
11537 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11538 0 : arg2 = *(OGRStyleTableShadow **)&jarg2;
11539 0 : GDALDatasetShadow_SetStyleTable(arg1,arg2);
11540 0 : }
11541 :
11542 :
11543 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetLayerByIndex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
11544 0 : jlong jresult = 0 ;
11545 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11546 : int arg2 ;
11547 0 : OGRLayerShadow *result = 0 ;
11548 :
11549 : (void)jenv;
11550 : (void)jcls;
11551 : (void)jarg1_;
11552 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11553 0 : arg2 = (int)jarg2;
11554 0 : result = (OGRLayerShadow *)GDALDatasetShadow_GetLayerByIndex(arg1,arg2);
11555 0 : *(OGRLayerShadow **)&jresult = result;
11556 0 : return jresult;
11557 : }
11558 :
11559 :
11560 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetLayerByName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11561 0 : jlong jresult = 0 ;
11562 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11563 0 : char *arg2 = (char *) 0 ;
11564 0 : OGRLayerShadow *result = 0 ;
11565 :
11566 : (void)jenv;
11567 : (void)jcls;
11568 : (void)jarg1_;
11569 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11570 0 : arg2 = 0;
11571 0 : if (jarg2) {
11572 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11573 0 : if (!arg2) return 0;
11574 : }
11575 0 : result = (OGRLayerShadow *)GDALDatasetShadow_GetLayerByName(arg1,(char const *)arg2);
11576 0 : *(OGRLayerShadow **)&jresult = result;
11577 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11578 0 : return jresult;
11579 : }
11580 :
11581 :
11582 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ResetReading(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11583 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11584 :
11585 : (void)jenv;
11586 : (void)jcls;
11587 : (void)jarg1_;
11588 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11589 0 : GDALDatasetShadow_ResetReading(arg1);
11590 0 : }
11591 :
11592 :
11593 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetLayerCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11594 0 : jint jresult = 0 ;
11595 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11596 : int result;
11597 :
11598 : (void)jenv;
11599 : (void)jcls;
11600 : (void)jarg1_;
11601 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11602 0 : result = (int)GDALDatasetShadow_GetLayerCount(arg1);
11603 0 : jresult = (jint)result;
11604 0 : return jresult;
11605 : }
11606 :
11607 :
11608 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AbortSQL(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11609 0 : jint jresult = 0 ;
11610 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11611 : OGRErr result;
11612 :
11613 : (void)jenv;
11614 : (void)jcls;
11615 : (void)jarg1_;
11616 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11617 0 : result = (OGRErr)GDALDatasetShadow_AbortSQL(arg1);
11618 : {
11619 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11620 0 : if (result != 0 && bUseExceptions) {
11621 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11622 : OGRErrMessages(result));
11623 0 : return 0;
11624 : }
11625 0 : jresult = (jint)result;
11626 : }
11627 : {
11628 : /* %typemap(ret) OGRErr */
11629 : }
11630 0 : return jresult;
11631 : }
11632 :
11633 :
11634 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1StartTransaction_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
11635 0 : jint jresult = 0 ;
11636 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11637 : int arg2 ;
11638 : OGRErr result;
11639 :
11640 : (void)jenv;
11641 : (void)jcls;
11642 : (void)jarg1_;
11643 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11644 0 : arg2 = (int)jarg2;
11645 0 : result = (OGRErr)GDALDatasetShadow_StartTransaction__SWIG_0(arg1,arg2);
11646 : {
11647 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11648 0 : if (result != 0 && bUseExceptions) {
11649 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11650 : OGRErrMessages(result));
11651 0 : return 0;
11652 : }
11653 0 : jresult = (jint)result;
11654 : }
11655 : {
11656 : /* %typemap(ret) OGRErr */
11657 : }
11658 0 : return jresult;
11659 : }
11660 :
11661 :
11662 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1StartTransaction_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11663 0 : jint jresult = 0 ;
11664 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11665 : OGRErr result;
11666 :
11667 : (void)jenv;
11668 : (void)jcls;
11669 : (void)jarg1_;
11670 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11671 0 : result = (OGRErr)GDALDatasetShadow_StartTransaction__SWIG_0(arg1);
11672 : {
11673 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11674 0 : if (result != 0 && bUseExceptions) {
11675 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11676 : OGRErrMessages(result));
11677 0 : return 0;
11678 : }
11679 0 : jresult = (jint)result;
11680 : }
11681 : {
11682 : /* %typemap(ret) OGRErr */
11683 : }
11684 0 : return jresult;
11685 : }
11686 :
11687 :
11688 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1CommitTransaction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11689 0 : jint jresult = 0 ;
11690 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11691 : OGRErr result;
11692 :
11693 : (void)jenv;
11694 : (void)jcls;
11695 : (void)jarg1_;
11696 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11697 0 : result = (OGRErr)GDALDatasetShadow_CommitTransaction(arg1);
11698 : {
11699 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11700 0 : if (result != 0 && bUseExceptions) {
11701 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11702 : OGRErrMessages(result));
11703 0 : return 0;
11704 : }
11705 0 : jresult = (jint)result;
11706 : }
11707 : {
11708 : /* %typemap(ret) OGRErr */
11709 : }
11710 0 : return jresult;
11711 : }
11712 :
11713 :
11714 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1RollbackTransaction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11715 0 : jint jresult = 0 ;
11716 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11717 : OGRErr result;
11718 :
11719 : (void)jenv;
11720 : (void)jcls;
11721 : (void)jarg1_;
11722 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11723 0 : result = (OGRErr)GDALDatasetShadow_RollbackTransaction(arg1);
11724 : {
11725 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
11726 0 : if (result != 0 && bUseExceptions) {
11727 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
11728 : OGRErrMessages(result));
11729 0 : return 0;
11730 : }
11731 0 : jresult = (jint)result;
11732 : }
11733 : {
11734 : /* %typemap(ret) OGRErr */
11735 : }
11736 0 : return jresult;
11737 : }
11738 :
11739 :
11740 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ClearStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11741 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11742 :
11743 : (void)jenv;
11744 : (void)jcls;
11745 : (void)jarg1_;
11746 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11747 0 : GDALDatasetShadow_ClearStatistics(arg1);
11748 0 : }
11749 :
11750 :
11751 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetFieldDomainNames_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
11752 0 : jobject jresult = 0 ;
11753 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11754 0 : char **arg2 = (char **) 0 ;
11755 0 : char **result = 0 ;
11756 :
11757 : (void)jenv;
11758 : (void)jcls;
11759 : (void)jarg1_;
11760 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11761 : {
11762 : /* %typemap(in) char **options */
11763 0 : arg2 = NULL;
11764 0 : if(jarg2 != 0) {
11765 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11766 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
11767 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
11768 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
11769 : "()Ljava/util/Enumeration;");
11770 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
11771 : "hasMoreElements", "()Z");
11772 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
11773 : "nextElement", "()Ljava/lang/Object;");
11774 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
11775 0 : hasMoreElements == NULL || getNextElement == NULL) {
11776 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
11777 0 : return 0;
11778 : }
11779 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
11780 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
11781 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
11782 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
11783 : {
11784 0 : CSLDestroy(arg2);
11785 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
11786 0 : return 0;
11787 : }
11788 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
11789 0 : arg2 = CSLAddString(arg2, valptr);
11790 0 : jenv->ReleaseStringUTFChars(value, valptr);
11791 : }
11792 : }
11793 : }
11794 0 : result = (char **)GDALDatasetShadow_GetFieldDomainNames__SWIG_0(arg1,arg2);
11795 : {
11796 : /* %typemap(out) char **CSL */
11797 0 : char **stringarray = result;
11798 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11799 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
11800 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
11801 :
11802 0 : jresult = jenv->NewObject(vector, constructor);
11803 0 : if ( stringarray != NULL ) {
11804 0 : while(*stringarray != NULL) {
11805 : /*printf("working on string %s\n", *stringarray);*/
11806 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
11807 0 : jenv->CallBooleanMethod(jresult, add, value);
11808 0 : jenv->DeleteLocalRef(value);
11809 0 : stringarray++;
11810 : }
11811 : }
11812 0 : CSLDestroy(result);
11813 : }
11814 : {
11815 : /* %typemap(freearg) char **options */
11816 0 : CSLDestroy( arg2 );
11817 : }
11818 0 : return jresult;
11819 : }
11820 :
11821 :
11822 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetFieldDomainNames_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
11823 0 : jobject jresult = 0 ;
11824 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11825 0 : char **result = 0 ;
11826 :
11827 : (void)jenv;
11828 : (void)jcls;
11829 : (void)jarg1_;
11830 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11831 0 : result = (char **)GDALDatasetShadow_GetFieldDomainNames__SWIG_0(arg1);
11832 : {
11833 : /* %typemap(out) char **CSL */
11834 0 : char **stringarray = result;
11835 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11836 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
11837 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
11838 :
11839 0 : jresult = jenv->NewObject(vector, constructor);
11840 0 : if ( stringarray != NULL ) {
11841 0 : while(*stringarray != NULL) {
11842 : /*printf("working on string %s\n", *stringarray);*/
11843 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
11844 0 : jenv->CallBooleanMethod(jresult, add, value);
11845 0 : jenv->DeleteLocalRef(value);
11846 0 : stringarray++;
11847 : }
11848 : }
11849 0 : CSLDestroy(result);
11850 : }
11851 0 : return jresult;
11852 : }
11853 :
11854 :
11855 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetFieldDomain(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11856 0 : jlong jresult = 0 ;
11857 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11858 0 : char *arg2 = (char *) 0 ;
11859 0 : OGRFieldDomainShadow *result = 0 ;
11860 :
11861 : (void)jenv;
11862 : (void)jcls;
11863 : (void)jarg1_;
11864 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11865 0 : arg2 = 0;
11866 0 : if (jarg2) {
11867 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11868 0 : if (!arg2) return 0;
11869 : }
11870 : {
11871 0 : if (!arg2) {
11872 : {
11873 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11874 : };
11875 : }
11876 : }
11877 0 : result = (OGRFieldDomainShadow *)GDALDatasetShadow_GetFieldDomain(arg1,(char const *)arg2);
11878 0 : *(OGRFieldDomainShadow **)&jresult = result;
11879 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11880 0 : return jresult;
11881 : }
11882 :
11883 :
11884 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AddFieldDomain(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
11885 0 : jboolean jresult = 0 ;
11886 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11887 0 : OGRFieldDomainShadow *arg2 = (OGRFieldDomainShadow *) 0 ;
11888 : bool result;
11889 :
11890 : (void)jenv;
11891 : (void)jcls;
11892 : (void)jarg1_;
11893 : (void)jarg2_;
11894 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11895 0 : arg2 = *(OGRFieldDomainShadow **)&jarg2;
11896 : {
11897 0 : if (!arg2) {
11898 : {
11899 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11900 : };
11901 : }
11902 : }
11903 0 : result = (bool)GDALDatasetShadow_AddFieldDomain(arg1,arg2);
11904 0 : jresult = (jboolean)result;
11905 0 : return jresult;
11906 : }
11907 :
11908 :
11909 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1DeleteFieldDomain(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
11910 0 : jboolean jresult = 0 ;
11911 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11912 0 : char *arg2 = (char *) 0 ;
11913 : bool result;
11914 :
11915 : (void)jenv;
11916 : (void)jcls;
11917 : (void)jarg1_;
11918 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11919 0 : arg2 = 0;
11920 0 : if (jarg2) {
11921 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
11922 0 : if (!arg2) return 0;
11923 : }
11924 : {
11925 0 : if (!arg2) {
11926 : {
11927 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11928 : };
11929 : }
11930 : }
11931 0 : result = (bool)GDALDatasetShadow_DeleteFieldDomain(arg1,(char const *)arg2);
11932 0 : jresult = (jboolean)result;
11933 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
11934 0 : return jresult;
11935 : }
11936 :
11937 :
11938 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1UpdateFieldDomain(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
11939 0 : jboolean jresult = 0 ;
11940 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11941 0 : OGRFieldDomainShadow *arg2 = (OGRFieldDomainShadow *) 0 ;
11942 : bool result;
11943 :
11944 : (void)jenv;
11945 : (void)jcls;
11946 : (void)jarg1_;
11947 : (void)jarg2_;
11948 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11949 0 : arg2 = *(OGRFieldDomainShadow **)&jarg2;
11950 : {
11951 0 : if (!arg2) {
11952 : {
11953 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
11954 : };
11955 : }
11956 : }
11957 0 : result = (bool)GDALDatasetShadow_UpdateFieldDomain(arg1,arg2);
11958 0 : jresult = (jboolean)result;
11959 0 : return jresult;
11960 : }
11961 :
11962 :
11963 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetRelationshipNames_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
11964 0 : jobject jresult = 0 ;
11965 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
11966 0 : char **arg2 = (char **) 0 ;
11967 0 : char **result = 0 ;
11968 :
11969 : (void)jenv;
11970 : (void)jcls;
11971 : (void)jarg1_;
11972 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
11973 : {
11974 : /* %typemap(in) char **options */
11975 0 : arg2 = NULL;
11976 0 : if(jarg2 != 0) {
11977 0 : const jclass vector = jenv->FindClass("java/util/Vector");
11978 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
11979 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
11980 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
11981 : "()Ljava/util/Enumeration;");
11982 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
11983 : "hasMoreElements", "()Z");
11984 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
11985 : "nextElement", "()Ljava/lang/Object;");
11986 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
11987 0 : hasMoreElements == NULL || getNextElement == NULL) {
11988 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
11989 0 : return 0;
11990 : }
11991 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
11992 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
11993 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
11994 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
11995 : {
11996 0 : CSLDestroy(arg2);
11997 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
11998 0 : return 0;
11999 : }
12000 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
12001 0 : arg2 = CSLAddString(arg2, valptr);
12002 0 : jenv->ReleaseStringUTFChars(value, valptr);
12003 : }
12004 : }
12005 : }
12006 0 : result = (char **)GDALDatasetShadow_GetRelationshipNames__SWIG_0(arg1,arg2);
12007 : {
12008 : /* %typemap(out) char **CSL */
12009 0 : char **stringarray = result;
12010 0 : const jclass vector = jenv->FindClass("java/util/Vector");
12011 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
12012 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
12013 :
12014 0 : jresult = jenv->NewObject(vector, constructor);
12015 0 : if ( stringarray != NULL ) {
12016 0 : while(*stringarray != NULL) {
12017 : /*printf("working on string %s\n", *stringarray);*/
12018 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
12019 0 : jenv->CallBooleanMethod(jresult, add, value);
12020 0 : jenv->DeleteLocalRef(value);
12021 0 : stringarray++;
12022 : }
12023 : }
12024 0 : CSLDestroy(result);
12025 : }
12026 : {
12027 : /* %typemap(freearg) char **options */
12028 0 : CSLDestroy( arg2 );
12029 : }
12030 0 : return jresult;
12031 : }
12032 :
12033 :
12034 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetRelationshipNames_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
12035 0 : jobject jresult = 0 ;
12036 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12037 0 : char **result = 0 ;
12038 :
12039 : (void)jenv;
12040 : (void)jcls;
12041 : (void)jarg1_;
12042 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12043 0 : result = (char **)GDALDatasetShadow_GetRelationshipNames__SWIG_0(arg1);
12044 : {
12045 : /* %typemap(out) char **CSL */
12046 0 : char **stringarray = result;
12047 0 : const jclass vector = jenv->FindClass("java/util/Vector");
12048 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
12049 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
12050 :
12051 0 : jresult = jenv->NewObject(vector, constructor);
12052 0 : if ( stringarray != NULL ) {
12053 0 : while(*stringarray != NULL) {
12054 : /*printf("working on string %s\n", *stringarray);*/
12055 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
12056 0 : jenv->CallBooleanMethod(jresult, add, value);
12057 0 : jenv->DeleteLocalRef(value);
12058 0 : stringarray++;
12059 : }
12060 : }
12061 0 : CSLDestroy(result);
12062 : }
12063 0 : return jresult;
12064 : }
12065 :
12066 :
12067 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1GetRelationship(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
12068 0 : jlong jresult = 0 ;
12069 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12070 0 : char *arg2 = (char *) 0 ;
12071 0 : GDALRelationshipShadow *result = 0 ;
12072 :
12073 : (void)jenv;
12074 : (void)jcls;
12075 : (void)jarg1_;
12076 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12077 0 : arg2 = 0;
12078 0 : if (jarg2) {
12079 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
12080 0 : if (!arg2) return 0;
12081 : }
12082 : {
12083 0 : if (!arg2) {
12084 : {
12085 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
12086 : };
12087 : }
12088 : }
12089 0 : result = (GDALRelationshipShadow *)GDALDatasetShadow_GetRelationship(arg1,(char const *)arg2);
12090 0 : *(GDALRelationshipShadow **)&jresult = result;
12091 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
12092 0 : return jresult;
12093 : }
12094 :
12095 :
12096 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1AddRelationship(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
12097 0 : jboolean jresult = 0 ;
12098 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12099 0 : GDALRelationshipShadow *arg2 = (GDALRelationshipShadow *) 0 ;
12100 : bool result;
12101 :
12102 : (void)jenv;
12103 : (void)jcls;
12104 : (void)jarg1_;
12105 : (void)jarg2_;
12106 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12107 0 : arg2 = *(GDALRelationshipShadow **)&jarg2;
12108 : {
12109 0 : if (!arg2) {
12110 : {
12111 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
12112 : };
12113 : }
12114 : }
12115 0 : result = (bool)GDALDatasetShadow_AddRelationship(arg1,arg2);
12116 0 : jresult = (jboolean)result;
12117 0 : return jresult;
12118 : }
12119 :
12120 :
12121 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1DeleteRelationship(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
12122 0 : jboolean jresult = 0 ;
12123 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12124 0 : char *arg2 = (char *) 0 ;
12125 : bool result;
12126 :
12127 : (void)jenv;
12128 : (void)jcls;
12129 : (void)jarg1_;
12130 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12131 0 : arg2 = 0;
12132 0 : if (jarg2) {
12133 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
12134 0 : if (!arg2) return 0;
12135 : }
12136 : {
12137 0 : if (!arg2) {
12138 : {
12139 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
12140 : };
12141 : }
12142 : }
12143 0 : result = (bool)GDALDatasetShadow_DeleteRelationship(arg1,(char const *)arg2);
12144 0 : jresult = (jboolean)result;
12145 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
12146 0 : return jresult;
12147 : }
12148 :
12149 :
12150 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1UpdateRelationship(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
12151 0 : jboolean jresult = 0 ;
12152 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12153 0 : GDALRelationshipShadow *arg2 = (GDALRelationshipShadow *) 0 ;
12154 : bool result;
12155 :
12156 : (void)jenv;
12157 : (void)jcls;
12158 : (void)jarg1_;
12159 : (void)jarg2_;
12160 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12161 0 : arg2 = *(GDALRelationshipShadow **)&jarg2;
12162 : {
12163 0 : if (!arg2) {
12164 : {
12165 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
12166 : };
12167 : }
12168 : }
12169 0 : result = (bool)GDALDatasetShadow_UpdateRelationship(arg1,arg2);
12170 0 : jresult = (jboolean)result;
12171 0 : return jresult;
12172 : }
12173 :
12174 :
12175 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1Direct_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
12176 0 : jint jresult = 0 ;
12177 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12178 : int arg2 ;
12179 : int arg3 ;
12180 : int arg4 ;
12181 : int arg5 ;
12182 : int arg6 ;
12183 : int arg7 ;
12184 : GDALDataType arg8 ;
12185 0 : void *arg9 = (void *) 0 ;
12186 : size_t arg10 ;
12187 : int arg11 ;
12188 0 : int *arg12 = (int *) 0 ;
12189 : int arg13 ;
12190 : int arg14 ;
12191 : int arg15 ;
12192 : CPLErr result;
12193 :
12194 : (void)jenv;
12195 : (void)jcls;
12196 : (void)jarg1_;
12197 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12198 0 : arg2 = (int)jarg2;
12199 0 : arg3 = (int)jarg3;
12200 0 : arg4 = (int)jarg4;
12201 0 : arg5 = (int)jarg5;
12202 0 : arg6 = (int)jarg6;
12203 0 : arg7 = (int)jarg7;
12204 0 : arg8 = (GDALDataType)jarg8;
12205 : {
12206 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
12207 0 : if (jarg9 == 0)
12208 : {
12209 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12210 0 : return 0;
12211 : }
12212 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
12213 0 : if (arg9 == NULL)
12214 : {
12215 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12216 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
12217 0 : return 0;
12218 : }
12219 :
12220 : /* The cast to size_t is actually not that correct, but anyway afterwards */
12221 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
12222 : /* so truncating to INT_MAX is OK */
12223 :
12224 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
12225 : }
12226 : {
12227 : /* %typemap(in) (int nList, int* pList) */
12228 : /* check if is List */
12229 0 : if (jarg11)
12230 : {
12231 0 : arg11 = jenv->GetArrayLength(jarg11);
12232 0 : if (arg11 == 0)
12233 0 : arg12 = NULL;
12234 : else
12235 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12236 : }
12237 : else
12238 : {
12239 0 : arg11 = 0;
12240 0 : arg12 = NULL;
12241 : }
12242 : }
12243 0 : arg13 = (int)jarg13;
12244 0 : arg14 = (int)jarg14;
12245 0 : arg15 = (int)jarg15;
12246 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
12247 0 : jresult = (jint)result;
12248 : {
12249 : /* %typemap(argout) (int nList, int* pList) */
12250 : }
12251 : {
12252 : /* %typemap(freearg) (int nList, int* pList) */
12253 0 : if (arg12) {
12254 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12255 : }
12256 : }
12257 0 : return jresult;
12258 : }
12259 :
12260 :
12261 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1Direct_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
12262 0 : jint jresult = 0 ;
12263 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12264 : int arg2 ;
12265 : int arg3 ;
12266 : int arg4 ;
12267 : int arg5 ;
12268 : int arg6 ;
12269 : int arg7 ;
12270 : GDALDataType arg8 ;
12271 0 : void *arg9 = (void *) 0 ;
12272 : size_t arg10 ;
12273 : int arg11 ;
12274 0 : int *arg12 = (int *) 0 ;
12275 : int arg13 ;
12276 : int arg14 ;
12277 : CPLErr result;
12278 :
12279 : (void)jenv;
12280 : (void)jcls;
12281 : (void)jarg1_;
12282 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12283 0 : arg2 = (int)jarg2;
12284 0 : arg3 = (int)jarg3;
12285 0 : arg4 = (int)jarg4;
12286 0 : arg5 = (int)jarg5;
12287 0 : arg6 = (int)jarg6;
12288 0 : arg7 = (int)jarg7;
12289 0 : arg8 = (GDALDataType)jarg8;
12290 : {
12291 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
12292 0 : if (jarg9 == 0)
12293 : {
12294 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12295 0 : return 0;
12296 : }
12297 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
12298 0 : if (arg9 == NULL)
12299 : {
12300 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12301 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
12302 0 : return 0;
12303 : }
12304 :
12305 : /* The cast to size_t is actually not that correct, but anyway afterwards */
12306 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
12307 : /* so truncating to INT_MAX is OK */
12308 :
12309 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
12310 : }
12311 : {
12312 : /* %typemap(in) (int nList, int* pList) */
12313 : /* check if is List */
12314 0 : if (jarg11)
12315 : {
12316 0 : arg11 = jenv->GetArrayLength(jarg11);
12317 0 : if (arg11 == 0)
12318 0 : arg12 = NULL;
12319 : else
12320 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12321 : }
12322 : else
12323 : {
12324 0 : arg11 = 0;
12325 0 : arg12 = NULL;
12326 : }
12327 : }
12328 0 : arg13 = (int)jarg13;
12329 0 : arg14 = (int)jarg14;
12330 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12331 0 : jresult = (jint)result;
12332 : {
12333 : /* %typemap(argout) (int nList, int* pList) */
12334 : }
12335 : {
12336 : /* %typemap(freearg) (int nList, int* pList) */
12337 0 : if (arg12) {
12338 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12339 : }
12340 : }
12341 0 : return jresult;
12342 : }
12343 :
12344 :
12345 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1Direct_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13) {
12346 0 : jint jresult = 0 ;
12347 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12348 : int arg2 ;
12349 : int arg3 ;
12350 : int arg4 ;
12351 : int arg5 ;
12352 : int arg6 ;
12353 : int arg7 ;
12354 : GDALDataType arg8 ;
12355 0 : void *arg9 = (void *) 0 ;
12356 : size_t arg10 ;
12357 : int arg11 ;
12358 0 : int *arg12 = (int *) 0 ;
12359 : int arg13 ;
12360 : CPLErr result;
12361 :
12362 : (void)jenv;
12363 : (void)jcls;
12364 : (void)jarg1_;
12365 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12366 0 : arg2 = (int)jarg2;
12367 0 : arg3 = (int)jarg3;
12368 0 : arg4 = (int)jarg4;
12369 0 : arg5 = (int)jarg5;
12370 0 : arg6 = (int)jarg6;
12371 0 : arg7 = (int)jarg7;
12372 0 : arg8 = (GDALDataType)jarg8;
12373 : {
12374 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
12375 0 : if (jarg9 == 0)
12376 : {
12377 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12378 0 : return 0;
12379 : }
12380 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
12381 0 : if (arg9 == NULL)
12382 : {
12383 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12384 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
12385 0 : return 0;
12386 : }
12387 :
12388 : /* The cast to size_t is actually not that correct, but anyway afterwards */
12389 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
12390 : /* so truncating to INT_MAX is OK */
12391 :
12392 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
12393 : }
12394 : {
12395 : /* %typemap(in) (int nList, int* pList) */
12396 : /* check if is List */
12397 0 : if (jarg11)
12398 : {
12399 0 : arg11 = jenv->GetArrayLength(jarg11);
12400 0 : if (arg11 == 0)
12401 0 : arg12 = NULL;
12402 : else
12403 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12404 : }
12405 : else
12406 : {
12407 0 : arg11 = 0;
12408 0 : arg12 = NULL;
12409 : }
12410 : }
12411 0 : arg13 = (int)jarg13;
12412 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12413 0 : jresult = (jint)result;
12414 : {
12415 : /* %typemap(argout) (int nList, int* pList) */
12416 : }
12417 : {
12418 : /* %typemap(freearg) (int nList, int* pList) */
12419 0 : if (arg12) {
12420 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12421 : }
12422 : }
12423 0 : return jresult;
12424 : }
12425 :
12426 :
12427 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1Direct_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11) {
12428 0 : jint jresult = 0 ;
12429 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12430 : int arg2 ;
12431 : int arg3 ;
12432 : int arg4 ;
12433 : int arg5 ;
12434 : int arg6 ;
12435 : int arg7 ;
12436 : GDALDataType arg8 ;
12437 0 : void *arg9 = (void *) 0 ;
12438 : size_t arg10 ;
12439 : int arg11 ;
12440 0 : int *arg12 = (int *) 0 ;
12441 : CPLErr result;
12442 :
12443 : (void)jenv;
12444 : (void)jcls;
12445 : (void)jarg1_;
12446 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12447 0 : arg2 = (int)jarg2;
12448 0 : arg3 = (int)jarg3;
12449 0 : arg4 = (int)jarg4;
12450 0 : arg5 = (int)jarg5;
12451 0 : arg6 = (int)jarg6;
12452 0 : arg7 = (int)jarg7;
12453 0 : arg8 = (GDALDataType)jarg8;
12454 : {
12455 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
12456 0 : if (jarg9 == 0)
12457 : {
12458 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12459 0 : return 0;
12460 : }
12461 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
12462 0 : if (arg9 == NULL)
12463 : {
12464 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12465 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
12466 0 : return 0;
12467 : }
12468 :
12469 : /* The cast to size_t is actually not that correct, but anyway afterwards */
12470 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
12471 : /* so truncating to INT_MAX is OK */
12472 :
12473 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
12474 : }
12475 : {
12476 : /* %typemap(in) (int nList, int* pList) */
12477 : /* check if is List */
12478 0 : if (jarg11)
12479 : {
12480 0 : arg11 = jenv->GetArrayLength(jarg11);
12481 0 : if (arg11 == 0)
12482 0 : arg12 = NULL;
12483 : else
12484 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12485 : }
12486 : else
12487 : {
12488 0 : arg11 = 0;
12489 0 : arg12 = NULL;
12490 : }
12491 : }
12492 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
12493 0 : jresult = (jint)result;
12494 : {
12495 : /* %typemap(argout) (int nList, int* pList) */
12496 : }
12497 : {
12498 : /* %typemap(freearg) (int nList, int* pList) */
12499 0 : if (arg12) {
12500 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12501 : }
12502 : }
12503 0 : return jresult;
12504 : }
12505 :
12506 :
12507 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
12508 0 : jint jresult = 0 ;
12509 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12510 : int arg2 ;
12511 : int arg3 ;
12512 : int arg4 ;
12513 : int arg5 ;
12514 : int arg6 ;
12515 : int arg7 ;
12516 : GDALDataType arg8 ;
12517 0 : char *arg9 = (char *) 0 ;
12518 : size_t arg10 ;
12519 : int arg11 ;
12520 0 : int *arg12 = (int *) 0 ;
12521 : int arg13 ;
12522 : int arg14 ;
12523 : int arg15 ;
12524 : CPLErr result;
12525 :
12526 : (void)jenv;
12527 : (void)jcls;
12528 : (void)jarg1_;
12529 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12530 0 : arg2 = (int)jarg2;
12531 0 : arg3 = (int)jarg3;
12532 0 : arg4 = (int)jarg4;
12533 0 : arg5 = (int)jarg5;
12534 0 : arg6 = (int)jarg6;
12535 0 : arg7 = (int)jarg7;
12536 0 : arg8 = (GDALDataType)jarg8;
12537 : {
12538 0 : if (jarg9 == 0)
12539 : {
12540 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12541 0 : return 0;
12542 : }
12543 :
12544 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
12545 0 : arg9 = (char*) malloc(arg10);
12546 :
12547 0 : if (arg9 == NULL)
12548 : {
12549 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12550 : "Unable to allocate temporary buffer.");
12551 0 : return 0;
12552 : }
12553 : }
12554 : {
12555 : /* %typemap(in) (int nList, int* pList) */
12556 : /* check if is List */
12557 0 : if (jarg11)
12558 : {
12559 0 : arg11 = jenv->GetArrayLength(jarg11);
12560 0 : if (arg11 == 0)
12561 0 : arg12 = NULL;
12562 : else
12563 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12564 : }
12565 : else
12566 : {
12567 0 : arg11 = 0;
12568 0 : arg12 = NULL;
12569 : }
12570 : }
12571 0 : arg13 = (int)jarg13;
12572 0 : arg14 = (int)jarg14;
12573 0 : arg15 = (int)jarg15;
12574 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
12575 0 : jresult = (jint)result;
12576 : {
12577 : /* %typemap(argout) (int nList, int* pList) */
12578 : }
12579 : {
12580 0 : if (result == CE_None) // testing the CPL result
12581 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
12582 :
12583 0 : free(arg9);
12584 : }
12585 : {
12586 : /* %typemap(freearg) (int nList, int* pList) */
12587 0 : if (arg12) {
12588 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12589 : }
12590 : }
12591 0 : return jresult;
12592 : }
12593 :
12594 :
12595 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
12596 0 : jint jresult = 0 ;
12597 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12598 : int arg2 ;
12599 : int arg3 ;
12600 : int arg4 ;
12601 : int arg5 ;
12602 : int arg6 ;
12603 : int arg7 ;
12604 : GDALDataType arg8 ;
12605 0 : char *arg9 = (char *) 0 ;
12606 : size_t arg10 ;
12607 : int arg11 ;
12608 0 : int *arg12 = (int *) 0 ;
12609 : int arg13 ;
12610 : int arg14 ;
12611 : CPLErr result;
12612 :
12613 : (void)jenv;
12614 : (void)jcls;
12615 : (void)jarg1_;
12616 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12617 0 : arg2 = (int)jarg2;
12618 0 : arg3 = (int)jarg3;
12619 0 : arg4 = (int)jarg4;
12620 0 : arg5 = (int)jarg5;
12621 0 : arg6 = (int)jarg6;
12622 0 : arg7 = (int)jarg7;
12623 0 : arg8 = (GDALDataType)jarg8;
12624 : {
12625 0 : if (jarg9 == 0)
12626 : {
12627 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12628 0 : return 0;
12629 : }
12630 :
12631 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
12632 0 : arg9 = (char*) malloc(arg10);
12633 :
12634 0 : if (arg9 == NULL)
12635 : {
12636 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12637 : "Unable to allocate temporary buffer.");
12638 0 : return 0;
12639 : }
12640 : }
12641 : {
12642 : /* %typemap(in) (int nList, int* pList) */
12643 : /* check if is List */
12644 0 : if (jarg11)
12645 : {
12646 0 : arg11 = jenv->GetArrayLength(jarg11);
12647 0 : if (arg11 == 0)
12648 0 : arg12 = NULL;
12649 : else
12650 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12651 : }
12652 : else
12653 : {
12654 0 : arg11 = 0;
12655 0 : arg12 = NULL;
12656 : }
12657 : }
12658 0 : arg13 = (int)jarg13;
12659 0 : arg14 = (int)jarg14;
12660 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
12661 0 : jresult = (jint)result;
12662 : {
12663 : /* %typemap(argout) (int nList, int* pList) */
12664 : }
12665 : {
12666 0 : if (result == CE_None) // testing the CPL result
12667 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
12668 :
12669 0 : free(arg9);
12670 : }
12671 : {
12672 : /* %typemap(freearg) (int nList, int* pList) */
12673 0 : if (arg12) {
12674 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12675 : }
12676 : }
12677 0 : return jresult;
12678 : }
12679 :
12680 :
12681 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13) {
12682 0 : jint jresult = 0 ;
12683 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12684 : int arg2 ;
12685 : int arg3 ;
12686 : int arg4 ;
12687 : int arg5 ;
12688 : int arg6 ;
12689 : int arg7 ;
12690 : GDALDataType arg8 ;
12691 0 : char *arg9 = (char *) 0 ;
12692 : size_t arg10 ;
12693 : int arg11 ;
12694 0 : int *arg12 = (int *) 0 ;
12695 : int arg13 ;
12696 : CPLErr result;
12697 :
12698 : (void)jenv;
12699 : (void)jcls;
12700 : (void)jarg1_;
12701 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12702 0 : arg2 = (int)jarg2;
12703 0 : arg3 = (int)jarg3;
12704 0 : arg4 = (int)jarg4;
12705 0 : arg5 = (int)jarg5;
12706 0 : arg6 = (int)jarg6;
12707 0 : arg7 = (int)jarg7;
12708 0 : arg8 = (GDALDataType)jarg8;
12709 : {
12710 0 : if (jarg9 == 0)
12711 : {
12712 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12713 0 : return 0;
12714 : }
12715 :
12716 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
12717 0 : arg9 = (char*) malloc(arg10);
12718 :
12719 0 : if (arg9 == NULL)
12720 : {
12721 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12722 : "Unable to allocate temporary buffer.");
12723 0 : return 0;
12724 : }
12725 : }
12726 : {
12727 : /* %typemap(in) (int nList, int* pList) */
12728 : /* check if is List */
12729 0 : if (jarg11)
12730 : {
12731 0 : arg11 = jenv->GetArrayLength(jarg11);
12732 0 : if (arg11 == 0)
12733 0 : arg12 = NULL;
12734 : else
12735 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12736 : }
12737 : else
12738 : {
12739 0 : arg11 = 0;
12740 0 : arg12 = NULL;
12741 : }
12742 : }
12743 0 : arg13 = (int)jarg13;
12744 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
12745 0 : jresult = (jint)result;
12746 : {
12747 : /* %typemap(argout) (int nList, int* pList) */
12748 : }
12749 : {
12750 0 : if (result == CE_None) // testing the CPL result
12751 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
12752 :
12753 0 : free(arg9);
12754 : }
12755 : {
12756 : /* %typemap(freearg) (int nList, int* pList) */
12757 0 : if (arg12) {
12758 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12759 : }
12760 : }
12761 0 : return jresult;
12762 : }
12763 :
12764 :
12765 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11) {
12766 0 : jint jresult = 0 ;
12767 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12768 : int arg2 ;
12769 : int arg3 ;
12770 : int arg4 ;
12771 : int arg5 ;
12772 : int arg6 ;
12773 : int arg7 ;
12774 : GDALDataType arg8 ;
12775 0 : char *arg9 = (char *) 0 ;
12776 : size_t arg10 ;
12777 : int arg11 ;
12778 0 : int *arg12 = (int *) 0 ;
12779 : CPLErr result;
12780 :
12781 : (void)jenv;
12782 : (void)jcls;
12783 : (void)jarg1_;
12784 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12785 0 : arg2 = (int)jarg2;
12786 0 : arg3 = (int)jarg3;
12787 0 : arg4 = (int)jarg4;
12788 0 : arg5 = (int)jarg5;
12789 0 : arg6 = (int)jarg6;
12790 0 : arg7 = (int)jarg7;
12791 0 : arg8 = (GDALDataType)jarg8;
12792 : {
12793 0 : if (jarg9 == 0)
12794 : {
12795 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12796 0 : return 0;
12797 : }
12798 :
12799 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
12800 0 : arg9 = (char*) malloc(arg10);
12801 :
12802 0 : if (arg9 == NULL)
12803 : {
12804 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12805 : "Unable to allocate temporary buffer.");
12806 0 : return 0;
12807 : }
12808 : }
12809 : {
12810 : /* %typemap(in) (int nList, int* pList) */
12811 : /* check if is List */
12812 0 : if (jarg11)
12813 : {
12814 0 : arg11 = jenv->GetArrayLength(jarg11);
12815 0 : if (arg11 == 0)
12816 0 : arg12 = NULL;
12817 : else
12818 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12819 : }
12820 : else
12821 : {
12822 0 : arg11 = 0;
12823 0 : arg12 = NULL;
12824 : }
12825 : }
12826 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
12827 0 : jresult = (jint)result;
12828 : {
12829 : /* %typemap(argout) (int nList, int* pList) */
12830 : }
12831 : {
12832 0 : if (result == CE_None) // testing the CPL result
12833 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
12834 :
12835 0 : free(arg9);
12836 : }
12837 : {
12838 : /* %typemap(freearg) (int nList, int* pList) */
12839 0 : if (arg12) {
12840 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12841 : }
12842 : }
12843 0 : return jresult;
12844 : }
12845 :
12846 :
12847 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
12848 0 : jint jresult = 0 ;
12849 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12850 : int arg2 ;
12851 : int arg3 ;
12852 : int arg4 ;
12853 : int arg5 ;
12854 : int arg6 ;
12855 : int arg7 ;
12856 : GDALDataType arg8 ;
12857 0 : short *arg9 = (short *) 0 ;
12858 : size_t arg10 ;
12859 : int arg11 ;
12860 0 : int *arg12 = (int *) 0 ;
12861 : int arg13 ;
12862 : int arg14 ;
12863 : int arg15 ;
12864 : CPLErr result;
12865 :
12866 : (void)jenv;
12867 : (void)jcls;
12868 : (void)jarg1_;
12869 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12870 0 : arg2 = (int)jarg2;
12871 0 : arg3 = (int)jarg3;
12872 0 : arg4 = (int)jarg4;
12873 0 : arg5 = (int)jarg5;
12874 0 : arg6 = (int)jarg6;
12875 0 : arg7 = (int)jarg7;
12876 0 : arg8 = (GDALDataType)jarg8;
12877 : {
12878 0 : if (jarg9 == 0)
12879 : {
12880 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12881 0 : return 0;
12882 : }
12883 :
12884 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
12885 0 : arg9 = (short*) malloc(arg10);
12886 :
12887 0 : if (arg9 == NULL)
12888 : {
12889 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12890 : "Unable to allocate temporary buffer.");
12891 0 : return 0;
12892 : }
12893 : }
12894 : {
12895 : /* %typemap(in) (int nList, int* pList) */
12896 : /* check if is List */
12897 0 : if (jarg11)
12898 : {
12899 0 : arg11 = jenv->GetArrayLength(jarg11);
12900 0 : if (arg11 == 0)
12901 0 : arg12 = NULL;
12902 : else
12903 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12904 : }
12905 : else
12906 : {
12907 0 : arg11 = 0;
12908 0 : arg12 = NULL;
12909 : }
12910 : }
12911 0 : arg13 = (int)jarg13;
12912 0 : arg14 = (int)jarg14;
12913 0 : arg15 = (int)jarg15;
12914 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
12915 0 : jresult = (jint)result;
12916 : {
12917 : /* %typemap(argout) (int nList, int* pList) */
12918 : }
12919 : {
12920 0 : if (result == CE_None) // testing the CPL result
12921 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
12922 :
12923 0 : free(arg9);
12924 : }
12925 : {
12926 : /* %typemap(freearg) (int nList, int* pList) */
12927 0 : if (arg12) {
12928 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
12929 : }
12930 : }
12931 0 : return jresult;
12932 : }
12933 :
12934 :
12935 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
12936 0 : jint jresult = 0 ;
12937 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
12938 : int arg2 ;
12939 : int arg3 ;
12940 : int arg4 ;
12941 : int arg5 ;
12942 : int arg6 ;
12943 : int arg7 ;
12944 : GDALDataType arg8 ;
12945 0 : short *arg9 = (short *) 0 ;
12946 : size_t arg10 ;
12947 : int arg11 ;
12948 0 : int *arg12 = (int *) 0 ;
12949 : int arg13 ;
12950 : int arg14 ;
12951 : CPLErr result;
12952 :
12953 : (void)jenv;
12954 : (void)jcls;
12955 : (void)jarg1_;
12956 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
12957 0 : arg2 = (int)jarg2;
12958 0 : arg3 = (int)jarg3;
12959 0 : arg4 = (int)jarg4;
12960 0 : arg5 = (int)jarg5;
12961 0 : arg6 = (int)jarg6;
12962 0 : arg7 = (int)jarg7;
12963 0 : arg8 = (GDALDataType)jarg8;
12964 : {
12965 0 : if (jarg9 == 0)
12966 : {
12967 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
12968 0 : return 0;
12969 : }
12970 :
12971 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
12972 0 : arg9 = (short*) malloc(arg10);
12973 :
12974 0 : if (arg9 == NULL)
12975 : {
12976 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
12977 : "Unable to allocate temporary buffer.");
12978 0 : return 0;
12979 : }
12980 : }
12981 : {
12982 : /* %typemap(in) (int nList, int* pList) */
12983 : /* check if is List */
12984 0 : if (jarg11)
12985 : {
12986 0 : arg11 = jenv->GetArrayLength(jarg11);
12987 0 : if (arg11 == 0)
12988 0 : arg12 = NULL;
12989 : else
12990 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
12991 : }
12992 : else
12993 : {
12994 0 : arg11 = 0;
12995 0 : arg12 = NULL;
12996 : }
12997 : }
12998 0 : arg13 = (int)jarg13;
12999 0 : arg14 = (int)jarg14;
13000 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13001 0 : jresult = (jint)result;
13002 : {
13003 : /* %typemap(argout) (int nList, int* pList) */
13004 : }
13005 : {
13006 0 : if (result == CE_None) // testing the CPL result
13007 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
13008 :
13009 0 : free(arg9);
13010 : }
13011 : {
13012 : /* %typemap(freearg) (int nList, int* pList) */
13013 0 : if (arg12) {
13014 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13015 : }
13016 : }
13017 0 : return jresult;
13018 : }
13019 :
13020 :
13021 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13) {
13022 0 : jint jresult = 0 ;
13023 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13024 : int arg2 ;
13025 : int arg3 ;
13026 : int arg4 ;
13027 : int arg5 ;
13028 : int arg6 ;
13029 : int arg7 ;
13030 : GDALDataType arg8 ;
13031 0 : short *arg9 = (short *) 0 ;
13032 : size_t arg10 ;
13033 : int arg11 ;
13034 0 : int *arg12 = (int *) 0 ;
13035 : int arg13 ;
13036 : CPLErr result;
13037 :
13038 : (void)jenv;
13039 : (void)jcls;
13040 : (void)jarg1_;
13041 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13042 0 : arg2 = (int)jarg2;
13043 0 : arg3 = (int)jarg3;
13044 0 : arg4 = (int)jarg4;
13045 0 : arg5 = (int)jarg5;
13046 0 : arg6 = (int)jarg6;
13047 0 : arg7 = (int)jarg7;
13048 0 : arg8 = (GDALDataType)jarg8;
13049 : {
13050 0 : if (jarg9 == 0)
13051 : {
13052 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13053 0 : return 0;
13054 : }
13055 :
13056 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
13057 0 : arg9 = (short*) malloc(arg10);
13058 :
13059 0 : if (arg9 == NULL)
13060 : {
13061 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13062 : "Unable to allocate temporary buffer.");
13063 0 : return 0;
13064 : }
13065 : }
13066 : {
13067 : /* %typemap(in) (int nList, int* pList) */
13068 : /* check if is List */
13069 0 : if (jarg11)
13070 : {
13071 0 : arg11 = jenv->GetArrayLength(jarg11);
13072 0 : if (arg11 == 0)
13073 0 : arg12 = NULL;
13074 : else
13075 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13076 : }
13077 : else
13078 : {
13079 0 : arg11 = 0;
13080 0 : arg12 = NULL;
13081 : }
13082 : }
13083 0 : arg13 = (int)jarg13;
13084 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13085 0 : jresult = (jint)result;
13086 : {
13087 : /* %typemap(argout) (int nList, int* pList) */
13088 : }
13089 : {
13090 0 : if (result == CE_None) // testing the CPL result
13091 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
13092 :
13093 0 : free(arg9);
13094 : }
13095 : {
13096 : /* %typemap(freearg) (int nList, int* pList) */
13097 0 : if (arg12) {
13098 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13099 : }
13100 : }
13101 0 : return jresult;
13102 : }
13103 :
13104 :
13105 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11) {
13106 0 : jint jresult = 0 ;
13107 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13108 : int arg2 ;
13109 : int arg3 ;
13110 : int arg4 ;
13111 : int arg5 ;
13112 : int arg6 ;
13113 : int arg7 ;
13114 : GDALDataType arg8 ;
13115 0 : short *arg9 = (short *) 0 ;
13116 : size_t arg10 ;
13117 : int arg11 ;
13118 0 : int *arg12 = (int *) 0 ;
13119 : CPLErr result;
13120 :
13121 : (void)jenv;
13122 : (void)jcls;
13123 : (void)jarg1_;
13124 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13125 0 : arg2 = (int)jarg2;
13126 0 : arg3 = (int)jarg3;
13127 0 : arg4 = (int)jarg4;
13128 0 : arg5 = (int)jarg5;
13129 0 : arg6 = (int)jarg6;
13130 0 : arg7 = (int)jarg7;
13131 0 : arg8 = (GDALDataType)jarg8;
13132 : {
13133 0 : if (jarg9 == 0)
13134 : {
13135 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13136 0 : return 0;
13137 : }
13138 :
13139 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
13140 0 : arg9 = (short*) malloc(arg10);
13141 :
13142 0 : if (arg9 == NULL)
13143 : {
13144 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13145 : "Unable to allocate temporary buffer.");
13146 0 : return 0;
13147 : }
13148 : }
13149 : {
13150 : /* %typemap(in) (int nList, int* pList) */
13151 : /* check if is List */
13152 0 : if (jarg11)
13153 : {
13154 0 : arg11 = jenv->GetArrayLength(jarg11);
13155 0 : if (arg11 == 0)
13156 0 : arg12 = NULL;
13157 : else
13158 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13159 : }
13160 : else
13161 : {
13162 0 : arg11 = 0;
13163 0 : arg12 = NULL;
13164 : }
13165 : }
13166 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13167 0 : jresult = (jint)result;
13168 : {
13169 : /* %typemap(argout) (int nList, int* pList) */
13170 : }
13171 : {
13172 0 : if (result == CE_None) // testing the CPL result
13173 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
13174 :
13175 0 : free(arg9);
13176 : }
13177 : {
13178 : /* %typemap(freearg) (int nList, int* pList) */
13179 0 : if (arg12) {
13180 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13181 : }
13182 : }
13183 0 : return jresult;
13184 : }
13185 :
13186 :
13187 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
13188 0 : jint jresult = 0 ;
13189 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13190 : int arg2 ;
13191 : int arg3 ;
13192 : int arg4 ;
13193 : int arg5 ;
13194 : int arg6 ;
13195 : int arg7 ;
13196 : GDALDataType arg8 ;
13197 0 : int *arg9 = (int *) 0 ;
13198 : size_t arg10 ;
13199 : int arg11 ;
13200 0 : int *arg12 = (int *) 0 ;
13201 : int arg13 ;
13202 : int arg14 ;
13203 : int arg15 ;
13204 : CPLErr result;
13205 :
13206 : (void)jenv;
13207 : (void)jcls;
13208 : (void)jarg1_;
13209 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13210 0 : arg2 = (int)jarg2;
13211 0 : arg3 = (int)jarg3;
13212 0 : arg4 = (int)jarg4;
13213 0 : arg5 = (int)jarg5;
13214 0 : arg6 = (int)jarg6;
13215 0 : arg7 = (int)jarg7;
13216 0 : arg8 = (GDALDataType)jarg8;
13217 : {
13218 0 : if (jarg9 == 0)
13219 : {
13220 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13221 0 : return 0;
13222 : }
13223 :
13224 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
13225 0 : arg9 = (int*) malloc(arg10);
13226 :
13227 0 : if (arg9 == NULL)
13228 : {
13229 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13230 : "Unable to allocate temporary buffer.");
13231 0 : return 0;
13232 : }
13233 : }
13234 : {
13235 : /* %typemap(in) (int nList, int* pList) */
13236 : /* check if is List */
13237 0 : if (jarg11)
13238 : {
13239 0 : arg11 = jenv->GetArrayLength(jarg11);
13240 0 : if (arg11 == 0)
13241 0 : arg12 = NULL;
13242 : else
13243 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13244 : }
13245 : else
13246 : {
13247 0 : arg11 = 0;
13248 0 : arg12 = NULL;
13249 : }
13250 : }
13251 0 : arg13 = (int)jarg13;
13252 0 : arg14 = (int)jarg14;
13253 0 : arg15 = (int)jarg15;
13254 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
13255 0 : jresult = (jint)result;
13256 : {
13257 : /* %typemap(argout) (int nList, int* pList) */
13258 : }
13259 : {
13260 0 : if (result == CE_None) // testing the CPL result
13261 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
13262 :
13263 0 : free(arg9);
13264 : }
13265 : {
13266 : /* %typemap(freearg) (int nList, int* pList) */
13267 0 : if (arg12) {
13268 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13269 : }
13270 : }
13271 0 : return jresult;
13272 : }
13273 :
13274 :
13275 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
13276 0 : jint jresult = 0 ;
13277 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13278 : int arg2 ;
13279 : int arg3 ;
13280 : int arg4 ;
13281 : int arg5 ;
13282 : int arg6 ;
13283 : int arg7 ;
13284 : GDALDataType arg8 ;
13285 0 : int *arg9 = (int *) 0 ;
13286 : size_t arg10 ;
13287 : int arg11 ;
13288 0 : int *arg12 = (int *) 0 ;
13289 : int arg13 ;
13290 : int arg14 ;
13291 : CPLErr result;
13292 :
13293 : (void)jenv;
13294 : (void)jcls;
13295 : (void)jarg1_;
13296 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13297 0 : arg2 = (int)jarg2;
13298 0 : arg3 = (int)jarg3;
13299 0 : arg4 = (int)jarg4;
13300 0 : arg5 = (int)jarg5;
13301 0 : arg6 = (int)jarg6;
13302 0 : arg7 = (int)jarg7;
13303 0 : arg8 = (GDALDataType)jarg8;
13304 : {
13305 0 : if (jarg9 == 0)
13306 : {
13307 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13308 0 : return 0;
13309 : }
13310 :
13311 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
13312 0 : arg9 = (int*) malloc(arg10);
13313 :
13314 0 : if (arg9 == NULL)
13315 : {
13316 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13317 : "Unable to allocate temporary buffer.");
13318 0 : return 0;
13319 : }
13320 : }
13321 : {
13322 : /* %typemap(in) (int nList, int* pList) */
13323 : /* check if is List */
13324 0 : if (jarg11)
13325 : {
13326 0 : arg11 = jenv->GetArrayLength(jarg11);
13327 0 : if (arg11 == 0)
13328 0 : arg12 = NULL;
13329 : else
13330 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13331 : }
13332 : else
13333 : {
13334 0 : arg11 = 0;
13335 0 : arg12 = NULL;
13336 : }
13337 : }
13338 0 : arg13 = (int)jarg13;
13339 0 : arg14 = (int)jarg14;
13340 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13341 0 : jresult = (jint)result;
13342 : {
13343 : /* %typemap(argout) (int nList, int* pList) */
13344 : }
13345 : {
13346 0 : if (result == CE_None) // testing the CPL result
13347 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
13348 :
13349 0 : free(arg9);
13350 : }
13351 : {
13352 : /* %typemap(freearg) (int nList, int* pList) */
13353 0 : if (arg12) {
13354 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13355 : }
13356 : }
13357 0 : return jresult;
13358 : }
13359 :
13360 :
13361 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13) {
13362 0 : jint jresult = 0 ;
13363 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13364 : int arg2 ;
13365 : int arg3 ;
13366 : int arg4 ;
13367 : int arg5 ;
13368 : int arg6 ;
13369 : int arg7 ;
13370 : GDALDataType arg8 ;
13371 0 : int *arg9 = (int *) 0 ;
13372 : size_t arg10 ;
13373 : int arg11 ;
13374 0 : int *arg12 = (int *) 0 ;
13375 : int arg13 ;
13376 : CPLErr result;
13377 :
13378 : (void)jenv;
13379 : (void)jcls;
13380 : (void)jarg1_;
13381 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13382 0 : arg2 = (int)jarg2;
13383 0 : arg3 = (int)jarg3;
13384 0 : arg4 = (int)jarg4;
13385 0 : arg5 = (int)jarg5;
13386 0 : arg6 = (int)jarg6;
13387 0 : arg7 = (int)jarg7;
13388 0 : arg8 = (GDALDataType)jarg8;
13389 : {
13390 0 : if (jarg9 == 0)
13391 : {
13392 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13393 0 : return 0;
13394 : }
13395 :
13396 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
13397 0 : arg9 = (int*) malloc(arg10);
13398 :
13399 0 : if (arg9 == NULL)
13400 : {
13401 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13402 : "Unable to allocate temporary buffer.");
13403 0 : return 0;
13404 : }
13405 : }
13406 : {
13407 : /* %typemap(in) (int nList, int* pList) */
13408 : /* check if is List */
13409 0 : if (jarg11)
13410 : {
13411 0 : arg11 = jenv->GetArrayLength(jarg11);
13412 0 : if (arg11 == 0)
13413 0 : arg12 = NULL;
13414 : else
13415 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13416 : }
13417 : else
13418 : {
13419 0 : arg11 = 0;
13420 0 : arg12 = NULL;
13421 : }
13422 : }
13423 0 : arg13 = (int)jarg13;
13424 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13425 0 : jresult = (jint)result;
13426 : {
13427 : /* %typemap(argout) (int nList, int* pList) */
13428 : }
13429 : {
13430 0 : if (result == CE_None) // testing the CPL result
13431 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
13432 :
13433 0 : free(arg9);
13434 : }
13435 : {
13436 : /* %typemap(freearg) (int nList, int* pList) */
13437 0 : if (arg12) {
13438 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13439 : }
13440 : }
13441 0 : return jresult;
13442 : }
13443 :
13444 :
13445 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_111(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11) {
13446 0 : jint jresult = 0 ;
13447 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13448 : int arg2 ;
13449 : int arg3 ;
13450 : int arg4 ;
13451 : int arg5 ;
13452 : int arg6 ;
13453 : int arg7 ;
13454 : GDALDataType arg8 ;
13455 0 : int *arg9 = (int *) 0 ;
13456 : size_t arg10 ;
13457 : int arg11 ;
13458 0 : int *arg12 = (int *) 0 ;
13459 : CPLErr result;
13460 :
13461 : (void)jenv;
13462 : (void)jcls;
13463 : (void)jarg1_;
13464 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13465 0 : arg2 = (int)jarg2;
13466 0 : arg3 = (int)jarg3;
13467 0 : arg4 = (int)jarg4;
13468 0 : arg5 = (int)jarg5;
13469 0 : arg6 = (int)jarg6;
13470 0 : arg7 = (int)jarg7;
13471 0 : arg8 = (GDALDataType)jarg8;
13472 : {
13473 0 : if (jarg9 == 0)
13474 : {
13475 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13476 0 : return 0;
13477 : }
13478 :
13479 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
13480 0 : arg9 = (int*) malloc(arg10);
13481 :
13482 0 : if (arg9 == NULL)
13483 : {
13484 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13485 : "Unable to allocate temporary buffer.");
13486 0 : return 0;
13487 : }
13488 : }
13489 : {
13490 : /* %typemap(in) (int nList, int* pList) */
13491 : /* check if is List */
13492 0 : if (jarg11)
13493 : {
13494 0 : arg11 = jenv->GetArrayLength(jarg11);
13495 0 : if (arg11 == 0)
13496 0 : arg12 = NULL;
13497 : else
13498 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13499 : }
13500 : else
13501 : {
13502 0 : arg11 = 0;
13503 0 : arg12 = NULL;
13504 : }
13505 : }
13506 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13507 0 : jresult = (jint)result;
13508 : {
13509 : /* %typemap(argout) (int nList, int* pList) */
13510 : }
13511 : {
13512 0 : if (result == CE_None) // testing the CPL result
13513 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
13514 :
13515 0 : free(arg9);
13516 : }
13517 : {
13518 : /* %typemap(freearg) (int nList, int* pList) */
13519 0 : if (arg12) {
13520 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13521 : }
13522 : }
13523 0 : return jresult;
13524 : }
13525 :
13526 :
13527 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_112(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
13528 0 : jint jresult = 0 ;
13529 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13530 : int arg2 ;
13531 : int arg3 ;
13532 : int arg4 ;
13533 : int arg5 ;
13534 : int arg6 ;
13535 : int arg7 ;
13536 : GDALDataType arg8 ;
13537 0 : int64_t *arg9 = (int64_t *) 0 ;
13538 : size_t arg10 ;
13539 : int arg11 ;
13540 0 : int *arg12 = (int *) 0 ;
13541 : int arg13 ;
13542 : int arg14 ;
13543 : int arg15 ;
13544 : CPLErr result;
13545 :
13546 : (void)jenv;
13547 : (void)jcls;
13548 : (void)jarg1_;
13549 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13550 0 : arg2 = (int)jarg2;
13551 0 : arg3 = (int)jarg3;
13552 0 : arg4 = (int)jarg4;
13553 0 : arg5 = (int)jarg5;
13554 0 : arg6 = (int)jarg6;
13555 0 : arg7 = (int)jarg7;
13556 0 : arg8 = (GDALDataType)jarg8;
13557 : {
13558 0 : if (jarg9 == 0)
13559 : {
13560 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13561 0 : return 0;
13562 : }
13563 :
13564 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
13565 0 : arg9 = (int64_t*) malloc(arg10);
13566 :
13567 0 : if (arg9 == NULL)
13568 : {
13569 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13570 : "Unable to allocate temporary buffer.");
13571 0 : return 0;
13572 : }
13573 : }
13574 : {
13575 : /* %typemap(in) (int nList, int* pList) */
13576 : /* check if is List */
13577 0 : if (jarg11)
13578 : {
13579 0 : arg11 = jenv->GetArrayLength(jarg11);
13580 0 : if (arg11 == 0)
13581 0 : arg12 = NULL;
13582 : else
13583 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13584 : }
13585 : else
13586 : {
13587 0 : arg11 = 0;
13588 0 : arg12 = NULL;
13589 : }
13590 : }
13591 0 : arg13 = (int)jarg13;
13592 0 : arg14 = (int)jarg14;
13593 0 : arg15 = (int)jarg15;
13594 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
13595 0 : jresult = (jint)result;
13596 : {
13597 : /* %typemap(argout) (int nList, int* pList) */
13598 : }
13599 : {
13600 0 : if (result == CE_None) // testing the CPL result
13601 0 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
13602 :
13603 0 : free(arg9);
13604 : }
13605 : {
13606 : /* %typemap(freearg) (int nList, int* pList) */
13607 0 : if (arg12) {
13608 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13609 : }
13610 : }
13611 0 : return jresult;
13612 : }
13613 :
13614 :
13615 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_113(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
13616 0 : jint jresult = 0 ;
13617 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13618 : int arg2 ;
13619 : int arg3 ;
13620 : int arg4 ;
13621 : int arg5 ;
13622 : int arg6 ;
13623 : int arg7 ;
13624 : GDALDataType arg8 ;
13625 0 : int64_t *arg9 = (int64_t *) 0 ;
13626 : size_t arg10 ;
13627 : int arg11 ;
13628 0 : int *arg12 = (int *) 0 ;
13629 : int arg13 ;
13630 : int arg14 ;
13631 : CPLErr result;
13632 :
13633 : (void)jenv;
13634 : (void)jcls;
13635 : (void)jarg1_;
13636 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13637 0 : arg2 = (int)jarg2;
13638 0 : arg3 = (int)jarg3;
13639 0 : arg4 = (int)jarg4;
13640 0 : arg5 = (int)jarg5;
13641 0 : arg6 = (int)jarg6;
13642 0 : arg7 = (int)jarg7;
13643 0 : arg8 = (GDALDataType)jarg8;
13644 : {
13645 0 : if (jarg9 == 0)
13646 : {
13647 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13648 0 : return 0;
13649 : }
13650 :
13651 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
13652 0 : arg9 = (int64_t*) malloc(arg10);
13653 :
13654 0 : if (arg9 == NULL)
13655 : {
13656 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13657 : "Unable to allocate temporary buffer.");
13658 0 : return 0;
13659 : }
13660 : }
13661 : {
13662 : /* %typemap(in) (int nList, int* pList) */
13663 : /* check if is List */
13664 0 : if (jarg11)
13665 : {
13666 0 : arg11 = jenv->GetArrayLength(jarg11);
13667 0 : if (arg11 == 0)
13668 0 : arg12 = NULL;
13669 : else
13670 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13671 : }
13672 : else
13673 : {
13674 0 : arg11 = 0;
13675 0 : arg12 = NULL;
13676 : }
13677 : }
13678 0 : arg13 = (int)jarg13;
13679 0 : arg14 = (int)jarg14;
13680 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
13681 0 : jresult = (jint)result;
13682 : {
13683 : /* %typemap(argout) (int nList, int* pList) */
13684 : }
13685 : {
13686 0 : if (result == CE_None) // testing the CPL result
13687 0 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
13688 :
13689 0 : free(arg9);
13690 : }
13691 : {
13692 : /* %typemap(freearg) (int nList, int* pList) */
13693 0 : if (arg12) {
13694 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13695 : }
13696 : }
13697 0 : return jresult;
13698 : }
13699 :
13700 :
13701 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_114(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13) {
13702 0 : jint jresult = 0 ;
13703 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13704 : int arg2 ;
13705 : int arg3 ;
13706 : int arg4 ;
13707 : int arg5 ;
13708 : int arg6 ;
13709 : int arg7 ;
13710 : GDALDataType arg8 ;
13711 0 : int64_t *arg9 = (int64_t *) 0 ;
13712 : size_t arg10 ;
13713 : int arg11 ;
13714 0 : int *arg12 = (int *) 0 ;
13715 : int arg13 ;
13716 : CPLErr result;
13717 :
13718 : (void)jenv;
13719 : (void)jcls;
13720 : (void)jarg1_;
13721 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13722 0 : arg2 = (int)jarg2;
13723 0 : arg3 = (int)jarg3;
13724 0 : arg4 = (int)jarg4;
13725 0 : arg5 = (int)jarg5;
13726 0 : arg6 = (int)jarg6;
13727 0 : arg7 = (int)jarg7;
13728 0 : arg8 = (GDALDataType)jarg8;
13729 : {
13730 0 : if (jarg9 == 0)
13731 : {
13732 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13733 0 : return 0;
13734 : }
13735 :
13736 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
13737 0 : arg9 = (int64_t*) malloc(arg10);
13738 :
13739 0 : if (arg9 == NULL)
13740 : {
13741 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13742 : "Unable to allocate temporary buffer.");
13743 0 : return 0;
13744 : }
13745 : }
13746 : {
13747 : /* %typemap(in) (int nList, int* pList) */
13748 : /* check if is List */
13749 0 : if (jarg11)
13750 : {
13751 0 : arg11 = jenv->GetArrayLength(jarg11);
13752 0 : if (arg11 == 0)
13753 0 : arg12 = NULL;
13754 : else
13755 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13756 : }
13757 : else
13758 : {
13759 0 : arg11 = 0;
13760 0 : arg12 = NULL;
13761 : }
13762 : }
13763 0 : arg13 = (int)jarg13;
13764 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
13765 0 : jresult = (jint)result;
13766 : {
13767 : /* %typemap(argout) (int nList, int* pList) */
13768 : }
13769 : {
13770 0 : if (result == CE_None) // testing the CPL result
13771 0 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
13772 :
13773 0 : free(arg9);
13774 : }
13775 : {
13776 : /* %typemap(freearg) (int nList, int* pList) */
13777 0 : if (arg12) {
13778 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13779 : }
13780 : }
13781 0 : return jresult;
13782 : }
13783 :
13784 :
13785 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_115(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11) {
13786 1 : jint jresult = 0 ;
13787 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13788 : int arg2 ;
13789 : int arg3 ;
13790 : int arg4 ;
13791 : int arg5 ;
13792 : int arg6 ;
13793 : int arg7 ;
13794 : GDALDataType arg8 ;
13795 1 : int64_t *arg9 = (int64_t *) 0 ;
13796 : size_t arg10 ;
13797 : int arg11 ;
13798 1 : int *arg12 = (int *) 0 ;
13799 : CPLErr result;
13800 :
13801 : (void)jenv;
13802 : (void)jcls;
13803 : (void)jarg1_;
13804 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
13805 1 : arg2 = (int)jarg2;
13806 1 : arg3 = (int)jarg3;
13807 1 : arg4 = (int)jarg4;
13808 1 : arg5 = (int)jarg5;
13809 1 : arg6 = (int)jarg6;
13810 1 : arg7 = (int)jarg7;
13811 1 : arg8 = (GDALDataType)jarg8;
13812 : {
13813 1 : if (jarg9 == 0)
13814 : {
13815 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13816 0 : return 0;
13817 : }
13818 :
13819 1 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
13820 1 : arg9 = (int64_t*) malloc(arg10);
13821 :
13822 1 : if (arg9 == NULL)
13823 : {
13824 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13825 : "Unable to allocate temporary buffer.");
13826 0 : return 0;
13827 : }
13828 : }
13829 : {
13830 : /* %typemap(in) (int nList, int* pList) */
13831 : /* check if is List */
13832 1 : if (jarg11)
13833 : {
13834 1 : arg11 = jenv->GetArrayLength(jarg11);
13835 1 : if (arg11 == 0)
13836 0 : arg12 = NULL;
13837 : else
13838 1 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13839 : }
13840 : else
13841 : {
13842 0 : arg11 = 0;
13843 0 : arg12 = NULL;
13844 : }
13845 : }
13846 1 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
13847 1 : jresult = (jint)result;
13848 : {
13849 : /* %typemap(argout) (int nList, int* pList) */
13850 : }
13851 : {
13852 1 : if (result == CE_None) // testing the CPL result
13853 1 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
13854 :
13855 1 : free(arg9);
13856 : }
13857 : {
13858 : /* %typemap(freearg) (int nList, int* pList) */
13859 1 : if (arg12) {
13860 1 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13861 : }
13862 : }
13863 1 : return jresult;
13864 : }
13865 :
13866 :
13867 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_116(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
13868 0 : jint jresult = 0 ;
13869 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13870 : int arg2 ;
13871 : int arg3 ;
13872 : int arg4 ;
13873 : int arg5 ;
13874 : int arg6 ;
13875 : int arg7 ;
13876 : GDALDataType arg8 ;
13877 0 : float *arg9 = (float *) 0 ;
13878 : size_t arg10 ;
13879 : int arg11 ;
13880 0 : int *arg12 = (int *) 0 ;
13881 : int arg13 ;
13882 : int arg14 ;
13883 : int arg15 ;
13884 : CPLErr result;
13885 :
13886 : (void)jenv;
13887 : (void)jcls;
13888 : (void)jarg1_;
13889 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13890 0 : arg2 = (int)jarg2;
13891 0 : arg3 = (int)jarg3;
13892 0 : arg4 = (int)jarg4;
13893 0 : arg5 = (int)jarg5;
13894 0 : arg6 = (int)jarg6;
13895 0 : arg7 = (int)jarg7;
13896 0 : arg8 = (GDALDataType)jarg8;
13897 : {
13898 0 : if (jarg9 == 0)
13899 : {
13900 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13901 0 : return 0;
13902 : }
13903 :
13904 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
13905 0 : arg9 = (float*) malloc(arg10);
13906 :
13907 0 : if (arg9 == NULL)
13908 : {
13909 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13910 : "Unable to allocate temporary buffer.");
13911 0 : return 0;
13912 : }
13913 : }
13914 : {
13915 : /* %typemap(in) (int nList, int* pList) */
13916 : /* check if is List */
13917 0 : if (jarg11)
13918 : {
13919 0 : arg11 = jenv->GetArrayLength(jarg11);
13920 0 : if (arg11 == 0)
13921 0 : arg12 = NULL;
13922 : else
13923 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
13924 : }
13925 : else
13926 : {
13927 0 : arg11 = 0;
13928 0 : arg12 = NULL;
13929 : }
13930 : }
13931 0 : arg13 = (int)jarg13;
13932 0 : arg14 = (int)jarg14;
13933 0 : arg15 = (int)jarg15;
13934 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
13935 0 : jresult = (jint)result;
13936 : {
13937 : /* %typemap(argout) (int nList, int* pList) */
13938 : }
13939 : {
13940 0 : if (result == CE_None) // testing the CPL result
13941 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
13942 :
13943 0 : free(arg9);
13944 : }
13945 : {
13946 : /* %typemap(freearg) (int nList, int* pList) */
13947 0 : if (arg12) {
13948 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
13949 : }
13950 : }
13951 0 : return jresult;
13952 : }
13953 :
13954 :
13955 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_117(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
13956 0 : jint jresult = 0 ;
13957 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
13958 : int arg2 ;
13959 : int arg3 ;
13960 : int arg4 ;
13961 : int arg5 ;
13962 : int arg6 ;
13963 : int arg7 ;
13964 : GDALDataType arg8 ;
13965 0 : float *arg9 = (float *) 0 ;
13966 : size_t arg10 ;
13967 : int arg11 ;
13968 0 : int *arg12 = (int *) 0 ;
13969 : int arg13 ;
13970 : int arg14 ;
13971 : CPLErr result;
13972 :
13973 : (void)jenv;
13974 : (void)jcls;
13975 : (void)jarg1_;
13976 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
13977 0 : arg2 = (int)jarg2;
13978 0 : arg3 = (int)jarg3;
13979 0 : arg4 = (int)jarg4;
13980 0 : arg5 = (int)jarg5;
13981 0 : arg6 = (int)jarg6;
13982 0 : arg7 = (int)jarg7;
13983 0 : arg8 = (GDALDataType)jarg8;
13984 : {
13985 0 : if (jarg9 == 0)
13986 : {
13987 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
13988 0 : return 0;
13989 : }
13990 :
13991 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
13992 0 : arg9 = (float*) malloc(arg10);
13993 :
13994 0 : if (arg9 == NULL)
13995 : {
13996 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
13997 : "Unable to allocate temporary buffer.");
13998 0 : return 0;
13999 : }
14000 : }
14001 : {
14002 : /* %typemap(in) (int nList, int* pList) */
14003 : /* check if is List */
14004 0 : if (jarg11)
14005 : {
14006 0 : arg11 = jenv->GetArrayLength(jarg11);
14007 0 : if (arg11 == 0)
14008 0 : arg12 = NULL;
14009 : else
14010 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14011 : }
14012 : else
14013 : {
14014 0 : arg11 = 0;
14015 0 : arg12 = NULL;
14016 : }
14017 : }
14018 0 : arg13 = (int)jarg13;
14019 0 : arg14 = (int)jarg14;
14020 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14021 0 : jresult = (jint)result;
14022 : {
14023 : /* %typemap(argout) (int nList, int* pList) */
14024 : }
14025 : {
14026 0 : if (result == CE_None) // testing the CPL result
14027 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
14028 :
14029 0 : free(arg9);
14030 : }
14031 : {
14032 : /* %typemap(freearg) (int nList, int* pList) */
14033 0 : if (arg12) {
14034 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14035 : }
14036 : }
14037 0 : return jresult;
14038 : }
14039 :
14040 :
14041 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_118(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13) {
14042 0 : jint jresult = 0 ;
14043 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14044 : int arg2 ;
14045 : int arg3 ;
14046 : int arg4 ;
14047 : int arg5 ;
14048 : int arg6 ;
14049 : int arg7 ;
14050 : GDALDataType arg8 ;
14051 0 : float *arg9 = (float *) 0 ;
14052 : size_t arg10 ;
14053 : int arg11 ;
14054 0 : int *arg12 = (int *) 0 ;
14055 : int arg13 ;
14056 : CPLErr result;
14057 :
14058 : (void)jenv;
14059 : (void)jcls;
14060 : (void)jarg1_;
14061 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14062 0 : arg2 = (int)jarg2;
14063 0 : arg3 = (int)jarg3;
14064 0 : arg4 = (int)jarg4;
14065 0 : arg5 = (int)jarg5;
14066 0 : arg6 = (int)jarg6;
14067 0 : arg7 = (int)jarg7;
14068 0 : arg8 = (GDALDataType)jarg8;
14069 : {
14070 0 : if (jarg9 == 0)
14071 : {
14072 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14073 0 : return 0;
14074 : }
14075 :
14076 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
14077 0 : arg9 = (float*) malloc(arg10);
14078 :
14079 0 : if (arg9 == NULL)
14080 : {
14081 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14082 : "Unable to allocate temporary buffer.");
14083 0 : return 0;
14084 : }
14085 : }
14086 : {
14087 : /* %typemap(in) (int nList, int* pList) */
14088 : /* check if is List */
14089 0 : if (jarg11)
14090 : {
14091 0 : arg11 = jenv->GetArrayLength(jarg11);
14092 0 : if (arg11 == 0)
14093 0 : arg12 = NULL;
14094 : else
14095 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14096 : }
14097 : else
14098 : {
14099 0 : arg11 = 0;
14100 0 : arg12 = NULL;
14101 : }
14102 : }
14103 0 : arg13 = (int)jarg13;
14104 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14105 0 : jresult = (jint)result;
14106 : {
14107 : /* %typemap(argout) (int nList, int* pList) */
14108 : }
14109 : {
14110 0 : if (result == CE_None) // testing the CPL result
14111 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
14112 :
14113 0 : free(arg9);
14114 : }
14115 : {
14116 : /* %typemap(freearg) (int nList, int* pList) */
14117 0 : if (arg12) {
14118 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14119 : }
14120 : }
14121 0 : return jresult;
14122 : }
14123 :
14124 :
14125 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_119(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11) {
14126 0 : jint jresult = 0 ;
14127 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14128 : int arg2 ;
14129 : int arg3 ;
14130 : int arg4 ;
14131 : int arg5 ;
14132 : int arg6 ;
14133 : int arg7 ;
14134 : GDALDataType arg8 ;
14135 0 : float *arg9 = (float *) 0 ;
14136 : size_t arg10 ;
14137 : int arg11 ;
14138 0 : int *arg12 = (int *) 0 ;
14139 : CPLErr result;
14140 :
14141 : (void)jenv;
14142 : (void)jcls;
14143 : (void)jarg1_;
14144 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14145 0 : arg2 = (int)jarg2;
14146 0 : arg3 = (int)jarg3;
14147 0 : arg4 = (int)jarg4;
14148 0 : arg5 = (int)jarg5;
14149 0 : arg6 = (int)jarg6;
14150 0 : arg7 = (int)jarg7;
14151 0 : arg8 = (GDALDataType)jarg8;
14152 : {
14153 0 : if (jarg9 == 0)
14154 : {
14155 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14156 0 : return 0;
14157 : }
14158 :
14159 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
14160 0 : arg9 = (float*) malloc(arg10);
14161 :
14162 0 : if (arg9 == NULL)
14163 : {
14164 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14165 : "Unable to allocate temporary buffer.");
14166 0 : return 0;
14167 : }
14168 : }
14169 : {
14170 : /* %typemap(in) (int nList, int* pList) */
14171 : /* check if is List */
14172 0 : if (jarg11)
14173 : {
14174 0 : arg11 = jenv->GetArrayLength(jarg11);
14175 0 : if (arg11 == 0)
14176 0 : arg12 = NULL;
14177 : else
14178 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14179 : }
14180 : else
14181 : {
14182 0 : arg11 = 0;
14183 0 : arg12 = NULL;
14184 : }
14185 : }
14186 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14187 0 : jresult = (jint)result;
14188 : {
14189 : /* %typemap(argout) (int nList, int* pList) */
14190 : }
14191 : {
14192 0 : if (result == CE_None) // testing the CPL result
14193 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
14194 :
14195 0 : free(arg9);
14196 : }
14197 : {
14198 : /* %typemap(freearg) (int nList, int* pList) */
14199 0 : if (arg12) {
14200 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14201 : }
14202 : }
14203 0 : return jresult;
14204 : }
14205 :
14206 :
14207 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_120(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
14208 0 : jint jresult = 0 ;
14209 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14210 : int arg2 ;
14211 : int arg3 ;
14212 : int arg4 ;
14213 : int arg5 ;
14214 : int arg6 ;
14215 : int arg7 ;
14216 : GDALDataType arg8 ;
14217 0 : double *arg9 = (double *) 0 ;
14218 : size_t arg10 ;
14219 : int arg11 ;
14220 0 : int *arg12 = (int *) 0 ;
14221 : int arg13 ;
14222 : int arg14 ;
14223 : int arg15 ;
14224 : CPLErr result;
14225 :
14226 : (void)jenv;
14227 : (void)jcls;
14228 : (void)jarg1_;
14229 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14230 0 : arg2 = (int)jarg2;
14231 0 : arg3 = (int)jarg3;
14232 0 : arg4 = (int)jarg4;
14233 0 : arg5 = (int)jarg5;
14234 0 : arg6 = (int)jarg6;
14235 0 : arg7 = (int)jarg7;
14236 0 : arg8 = (GDALDataType)jarg8;
14237 : {
14238 0 : if (jarg9 == 0)
14239 : {
14240 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14241 0 : return 0;
14242 : }
14243 :
14244 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
14245 0 : arg9 = (double*) malloc(arg10);
14246 :
14247 0 : if (arg9 == NULL)
14248 : {
14249 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14250 : "Unable to allocate temporary buffer.");
14251 0 : return 0;
14252 : }
14253 : }
14254 : {
14255 : /* %typemap(in) (int nList, int* pList) */
14256 : /* check if is List */
14257 0 : if (jarg11)
14258 : {
14259 0 : arg11 = jenv->GetArrayLength(jarg11);
14260 0 : if (arg11 == 0)
14261 0 : arg12 = NULL;
14262 : else
14263 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14264 : }
14265 : else
14266 : {
14267 0 : arg11 = 0;
14268 0 : arg12 = NULL;
14269 : }
14270 : }
14271 0 : arg13 = (int)jarg13;
14272 0 : arg14 = (int)jarg14;
14273 0 : arg15 = (int)jarg15;
14274 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
14275 0 : jresult = (jint)result;
14276 : {
14277 : /* %typemap(argout) (int nList, int* pList) */
14278 : }
14279 : {
14280 0 : if (result == CE_None) // testing the CPL result
14281 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
14282 :
14283 0 : free(arg9);
14284 : }
14285 : {
14286 : /* %typemap(freearg) (int nList, int* pList) */
14287 0 : if (arg12) {
14288 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14289 : }
14290 : }
14291 0 : return jresult;
14292 : }
14293 :
14294 :
14295 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_121(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
14296 0 : jint jresult = 0 ;
14297 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14298 : int arg2 ;
14299 : int arg3 ;
14300 : int arg4 ;
14301 : int arg5 ;
14302 : int arg6 ;
14303 : int arg7 ;
14304 : GDALDataType arg8 ;
14305 0 : double *arg9 = (double *) 0 ;
14306 : size_t arg10 ;
14307 : int arg11 ;
14308 0 : int *arg12 = (int *) 0 ;
14309 : int arg13 ;
14310 : int arg14 ;
14311 : CPLErr result;
14312 :
14313 : (void)jenv;
14314 : (void)jcls;
14315 : (void)jarg1_;
14316 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14317 0 : arg2 = (int)jarg2;
14318 0 : arg3 = (int)jarg3;
14319 0 : arg4 = (int)jarg4;
14320 0 : arg5 = (int)jarg5;
14321 0 : arg6 = (int)jarg6;
14322 0 : arg7 = (int)jarg7;
14323 0 : arg8 = (GDALDataType)jarg8;
14324 : {
14325 0 : if (jarg9 == 0)
14326 : {
14327 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14328 0 : return 0;
14329 : }
14330 :
14331 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
14332 0 : arg9 = (double*) malloc(arg10);
14333 :
14334 0 : if (arg9 == NULL)
14335 : {
14336 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14337 : "Unable to allocate temporary buffer.");
14338 0 : return 0;
14339 : }
14340 : }
14341 : {
14342 : /* %typemap(in) (int nList, int* pList) */
14343 : /* check if is List */
14344 0 : if (jarg11)
14345 : {
14346 0 : arg11 = jenv->GetArrayLength(jarg11);
14347 0 : if (arg11 == 0)
14348 0 : arg12 = NULL;
14349 : else
14350 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14351 : }
14352 : else
14353 : {
14354 0 : arg11 = 0;
14355 0 : arg12 = NULL;
14356 : }
14357 : }
14358 0 : arg13 = (int)jarg13;
14359 0 : arg14 = (int)jarg14;
14360 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14361 0 : jresult = (jint)result;
14362 : {
14363 : /* %typemap(argout) (int nList, int* pList) */
14364 : }
14365 : {
14366 0 : if (result == CE_None) // testing the CPL result
14367 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
14368 :
14369 0 : free(arg9);
14370 : }
14371 : {
14372 : /* %typemap(freearg) (int nList, int* pList) */
14373 0 : if (arg12) {
14374 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14375 : }
14376 : }
14377 0 : return jresult;
14378 : }
14379 :
14380 :
14381 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_122(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13) {
14382 0 : jint jresult = 0 ;
14383 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14384 : int arg2 ;
14385 : int arg3 ;
14386 : int arg4 ;
14387 : int arg5 ;
14388 : int arg6 ;
14389 : int arg7 ;
14390 : GDALDataType arg8 ;
14391 0 : double *arg9 = (double *) 0 ;
14392 : size_t arg10 ;
14393 : int arg11 ;
14394 0 : int *arg12 = (int *) 0 ;
14395 : int arg13 ;
14396 : CPLErr result;
14397 :
14398 : (void)jenv;
14399 : (void)jcls;
14400 : (void)jarg1_;
14401 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14402 0 : arg2 = (int)jarg2;
14403 0 : arg3 = (int)jarg3;
14404 0 : arg4 = (int)jarg4;
14405 0 : arg5 = (int)jarg5;
14406 0 : arg6 = (int)jarg6;
14407 0 : arg7 = (int)jarg7;
14408 0 : arg8 = (GDALDataType)jarg8;
14409 : {
14410 0 : if (jarg9 == 0)
14411 : {
14412 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14413 0 : return 0;
14414 : }
14415 :
14416 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
14417 0 : arg9 = (double*) malloc(arg10);
14418 :
14419 0 : if (arg9 == NULL)
14420 : {
14421 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14422 : "Unable to allocate temporary buffer.");
14423 0 : return 0;
14424 : }
14425 : }
14426 : {
14427 : /* %typemap(in) (int nList, int* pList) */
14428 : /* check if is List */
14429 0 : if (jarg11)
14430 : {
14431 0 : arg11 = jenv->GetArrayLength(jarg11);
14432 0 : if (arg11 == 0)
14433 0 : arg12 = NULL;
14434 : else
14435 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14436 : }
14437 : else
14438 : {
14439 0 : arg11 = 0;
14440 0 : arg12 = NULL;
14441 : }
14442 : }
14443 0 : arg13 = (int)jarg13;
14444 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14445 0 : jresult = (jint)result;
14446 : {
14447 : /* %typemap(argout) (int nList, int* pList) */
14448 : }
14449 : {
14450 0 : if (result == CE_None) // testing the CPL result
14451 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
14452 :
14453 0 : free(arg9);
14454 : }
14455 : {
14456 : /* %typemap(freearg) (int nList, int* pList) */
14457 0 : if (arg12) {
14458 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14459 : }
14460 : }
14461 0 : return jresult;
14462 : }
14463 :
14464 :
14465 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1ReadRaster_1_1SWIG_123(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11) {
14466 0 : jint jresult = 0 ;
14467 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14468 : int arg2 ;
14469 : int arg3 ;
14470 : int arg4 ;
14471 : int arg5 ;
14472 : int arg6 ;
14473 : int arg7 ;
14474 : GDALDataType arg8 ;
14475 0 : double *arg9 = (double *) 0 ;
14476 : size_t arg10 ;
14477 : int arg11 ;
14478 0 : int *arg12 = (int *) 0 ;
14479 : CPLErr result;
14480 :
14481 : (void)jenv;
14482 : (void)jcls;
14483 : (void)jarg1_;
14484 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14485 0 : arg2 = (int)jarg2;
14486 0 : arg3 = (int)jarg3;
14487 0 : arg4 = (int)jarg4;
14488 0 : arg5 = (int)jarg5;
14489 0 : arg6 = (int)jarg6;
14490 0 : arg7 = (int)jarg7;
14491 0 : arg8 = (GDALDataType)jarg8;
14492 : {
14493 0 : if (jarg9 == 0)
14494 : {
14495 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14496 0 : return 0;
14497 : }
14498 :
14499 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
14500 0 : arg9 = (double*) malloc(arg10);
14501 :
14502 0 : if (arg9 == NULL)
14503 : {
14504 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14505 : "Unable to allocate temporary buffer.");
14506 0 : return 0;
14507 : }
14508 : }
14509 : {
14510 : /* %typemap(in) (int nList, int* pList) */
14511 : /* check if is List */
14512 0 : if (jarg11)
14513 : {
14514 0 : arg11 = jenv->GetArrayLength(jarg11);
14515 0 : if (arg11 == 0)
14516 0 : arg12 = NULL;
14517 : else
14518 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14519 : }
14520 : else
14521 : {
14522 0 : arg11 = 0;
14523 0 : arg12 = NULL;
14524 : }
14525 : }
14526 0 : result = (CPLErr)GDALDatasetShadow_ReadRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14527 0 : jresult = (jint)result;
14528 : {
14529 : /* %typemap(argout) (int nList, int* pList) */
14530 : }
14531 : {
14532 0 : if (result == CE_None) // testing the CPL result
14533 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
14534 :
14535 0 : free(arg9);
14536 : }
14537 : {
14538 : /* %typemap(freearg) (int nList, int* pList) */
14539 0 : if (arg12) {
14540 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14541 : }
14542 : }
14543 0 : return jresult;
14544 : }
14545 :
14546 :
14547 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1Direct_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
14548 0 : jint jresult = 0 ;
14549 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14550 : int arg2 ;
14551 : int arg3 ;
14552 : int arg4 ;
14553 : int arg5 ;
14554 : int arg6 ;
14555 : int arg7 ;
14556 : GDALDataType arg8 ;
14557 0 : void *arg9 = (void *) 0 ;
14558 : size_t arg10 ;
14559 : int arg11 ;
14560 0 : int *arg12 = (int *) 0 ;
14561 : int arg13 ;
14562 : int arg14 ;
14563 : int arg15 ;
14564 : CPLErr result;
14565 :
14566 : (void)jenv;
14567 : (void)jcls;
14568 : (void)jarg1_;
14569 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14570 0 : arg2 = (int)jarg2;
14571 0 : arg3 = (int)jarg3;
14572 0 : arg4 = (int)jarg4;
14573 0 : arg5 = (int)jarg5;
14574 0 : arg6 = (int)jarg6;
14575 0 : arg7 = (int)jarg7;
14576 0 : arg8 = (GDALDataType)jarg8;
14577 : {
14578 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
14579 0 : if (jarg9 == 0)
14580 : {
14581 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14582 0 : return 0;
14583 : }
14584 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
14585 0 : if (arg9 == NULL)
14586 : {
14587 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14588 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
14589 0 : return 0;
14590 : }
14591 :
14592 : /* The cast to size_t is actually not that correct, but anyway afterwards */
14593 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
14594 : /* so truncating to INT_MAX is OK */
14595 :
14596 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
14597 : }
14598 : {
14599 : /* %typemap(in) (int nList, int* pList) */
14600 : /* check if is List */
14601 0 : if (jarg11)
14602 : {
14603 0 : arg11 = jenv->GetArrayLength(jarg11);
14604 0 : if (arg11 == 0)
14605 0 : arg12 = NULL;
14606 : else
14607 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14608 : }
14609 : else
14610 : {
14611 0 : arg11 = 0;
14612 0 : arg12 = NULL;
14613 : }
14614 : }
14615 0 : arg13 = (int)jarg13;
14616 0 : arg14 = (int)jarg14;
14617 0 : arg15 = (int)jarg15;
14618 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
14619 0 : jresult = (jint)result;
14620 : {
14621 : /* %typemap(argout) (int nList, int* pList) */
14622 : }
14623 : {
14624 : /* %typemap(freearg) (int nList, int* pList) */
14625 0 : if (arg12) {
14626 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14627 : }
14628 : }
14629 0 : return jresult;
14630 : }
14631 :
14632 :
14633 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1Direct_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
14634 0 : jint jresult = 0 ;
14635 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14636 : int arg2 ;
14637 : int arg3 ;
14638 : int arg4 ;
14639 : int arg5 ;
14640 : int arg6 ;
14641 : int arg7 ;
14642 : GDALDataType arg8 ;
14643 0 : void *arg9 = (void *) 0 ;
14644 : size_t arg10 ;
14645 : int arg11 ;
14646 0 : int *arg12 = (int *) 0 ;
14647 : int arg13 ;
14648 : int arg14 ;
14649 : CPLErr result;
14650 :
14651 : (void)jenv;
14652 : (void)jcls;
14653 : (void)jarg1_;
14654 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14655 0 : arg2 = (int)jarg2;
14656 0 : arg3 = (int)jarg3;
14657 0 : arg4 = (int)jarg4;
14658 0 : arg5 = (int)jarg5;
14659 0 : arg6 = (int)jarg6;
14660 0 : arg7 = (int)jarg7;
14661 0 : arg8 = (GDALDataType)jarg8;
14662 : {
14663 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
14664 0 : if (jarg9 == 0)
14665 : {
14666 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14667 0 : return 0;
14668 : }
14669 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
14670 0 : if (arg9 == NULL)
14671 : {
14672 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14673 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
14674 0 : return 0;
14675 : }
14676 :
14677 : /* The cast to size_t is actually not that correct, but anyway afterwards */
14678 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
14679 : /* so truncating to INT_MAX is OK */
14680 :
14681 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
14682 : }
14683 : {
14684 : /* %typemap(in) (int nList, int* pList) */
14685 : /* check if is List */
14686 0 : if (jarg11)
14687 : {
14688 0 : arg11 = jenv->GetArrayLength(jarg11);
14689 0 : if (arg11 == 0)
14690 0 : arg12 = NULL;
14691 : else
14692 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14693 : }
14694 : else
14695 : {
14696 0 : arg11 = 0;
14697 0 : arg12 = NULL;
14698 : }
14699 : }
14700 0 : arg13 = (int)jarg13;
14701 0 : arg14 = (int)jarg14;
14702 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
14703 0 : jresult = (jint)result;
14704 : {
14705 : /* %typemap(argout) (int nList, int* pList) */
14706 : }
14707 : {
14708 : /* %typemap(freearg) (int nList, int* pList) */
14709 0 : if (arg12) {
14710 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14711 : }
14712 : }
14713 0 : return jresult;
14714 : }
14715 :
14716 :
14717 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1Direct_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11, jint jarg13) {
14718 0 : jint jresult = 0 ;
14719 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14720 : int arg2 ;
14721 : int arg3 ;
14722 : int arg4 ;
14723 : int arg5 ;
14724 : int arg6 ;
14725 : int arg7 ;
14726 : GDALDataType arg8 ;
14727 0 : void *arg9 = (void *) 0 ;
14728 : size_t arg10 ;
14729 : int arg11 ;
14730 0 : int *arg12 = (int *) 0 ;
14731 : int arg13 ;
14732 : CPLErr result;
14733 :
14734 : (void)jenv;
14735 : (void)jcls;
14736 : (void)jarg1_;
14737 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14738 0 : arg2 = (int)jarg2;
14739 0 : arg3 = (int)jarg3;
14740 0 : arg4 = (int)jarg4;
14741 0 : arg5 = (int)jarg5;
14742 0 : arg6 = (int)jarg6;
14743 0 : arg7 = (int)jarg7;
14744 0 : arg8 = (GDALDataType)jarg8;
14745 : {
14746 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
14747 0 : if (jarg9 == 0)
14748 : {
14749 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14750 0 : return 0;
14751 : }
14752 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
14753 0 : if (arg9 == NULL)
14754 : {
14755 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14756 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
14757 0 : return 0;
14758 : }
14759 :
14760 : /* The cast to size_t is actually not that correct, but anyway afterwards */
14761 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
14762 : /* so truncating to INT_MAX is OK */
14763 :
14764 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
14765 : }
14766 : {
14767 : /* %typemap(in) (int nList, int* pList) */
14768 : /* check if is List */
14769 0 : if (jarg11)
14770 : {
14771 0 : arg11 = jenv->GetArrayLength(jarg11);
14772 0 : if (arg11 == 0)
14773 0 : arg12 = NULL;
14774 : else
14775 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14776 : }
14777 : else
14778 : {
14779 0 : arg11 = 0;
14780 0 : arg12 = NULL;
14781 : }
14782 : }
14783 0 : arg13 = (int)jarg13;
14784 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
14785 0 : jresult = (jint)result;
14786 : {
14787 : /* %typemap(argout) (int nList, int* pList) */
14788 : }
14789 : {
14790 : /* %typemap(freearg) (int nList, int* pList) */
14791 0 : if (arg12) {
14792 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14793 : }
14794 : }
14795 0 : return jresult;
14796 : }
14797 :
14798 :
14799 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1Direct_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jintArray jarg11) {
14800 0 : jint jresult = 0 ;
14801 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14802 : int arg2 ;
14803 : int arg3 ;
14804 : int arg4 ;
14805 : int arg5 ;
14806 : int arg6 ;
14807 : int arg7 ;
14808 : GDALDataType arg8 ;
14809 0 : void *arg9 = (void *) 0 ;
14810 : size_t arg10 ;
14811 : int arg11 ;
14812 0 : int *arg12 = (int *) 0 ;
14813 : CPLErr result;
14814 :
14815 : (void)jenv;
14816 : (void)jcls;
14817 : (void)jarg1_;
14818 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14819 0 : arg2 = (int)jarg2;
14820 0 : arg3 = (int)jarg3;
14821 0 : arg4 = (int)jarg4;
14822 0 : arg5 = (int)jarg5;
14823 0 : arg6 = (int)jarg6;
14824 0 : arg7 = (int)jarg7;
14825 0 : arg8 = (GDALDataType)jarg8;
14826 : {
14827 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
14828 0 : if (jarg9 == 0)
14829 : {
14830 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14831 0 : return 0;
14832 : }
14833 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
14834 0 : if (arg9 == NULL)
14835 : {
14836 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14837 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
14838 0 : return 0;
14839 : }
14840 :
14841 : /* The cast to size_t is actually not that correct, but anyway afterwards */
14842 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
14843 : /* so truncating to INT_MAX is OK */
14844 :
14845 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
14846 : }
14847 : {
14848 : /* %typemap(in) (int nList, int* pList) */
14849 : /* check if is List */
14850 0 : if (jarg11)
14851 : {
14852 0 : arg11 = jenv->GetArrayLength(jarg11);
14853 0 : if (arg11 == 0)
14854 0 : arg12 = NULL;
14855 : else
14856 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14857 : }
14858 : else
14859 : {
14860 0 : arg11 = 0;
14861 0 : arg12 = NULL;
14862 : }
14863 : }
14864 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
14865 0 : jresult = (jint)result;
14866 : {
14867 : /* %typemap(argout) (int nList, int* pList) */
14868 : }
14869 : {
14870 : /* %typemap(freearg) (int nList, int* pList) */
14871 0 : if (arg12) {
14872 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14873 : }
14874 : }
14875 0 : return jresult;
14876 : }
14877 :
14878 :
14879 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
14880 0 : jint jresult = 0 ;
14881 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14882 : int arg2 ;
14883 : int arg3 ;
14884 : int arg4 ;
14885 : int arg5 ;
14886 : int arg6 ;
14887 : int arg7 ;
14888 : GDALDataType arg8 ;
14889 0 : char *arg9 = (char *) 0 ;
14890 : size_t arg10 ;
14891 : int arg11 ;
14892 0 : int *arg12 = (int *) 0 ;
14893 : int arg13 ;
14894 : int arg14 ;
14895 : int arg15 ;
14896 : CPLErr result;
14897 :
14898 : (void)jenv;
14899 : (void)jcls;
14900 : (void)jarg1_;
14901 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14902 0 : arg2 = (int)jarg2;
14903 0 : arg3 = (int)jarg3;
14904 0 : arg4 = (int)jarg4;
14905 0 : arg5 = (int)jarg5;
14906 0 : arg6 = (int)jarg6;
14907 0 : arg7 = (int)jarg7;
14908 0 : arg8 = (GDALDataType)jarg8;
14909 : {
14910 0 : if (jarg9 == 0)
14911 : {
14912 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14913 0 : return 0;
14914 : }
14915 :
14916 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
14917 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
14918 0 : if (arg9 == NULL)
14919 : {
14920 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
14921 : "Unable to get buffer.");
14922 0 : return 0;
14923 : }
14924 : }
14925 : {
14926 : /* %typemap(in) (int nList, int* pList) */
14927 : /* check if is List */
14928 0 : if (jarg11)
14929 : {
14930 0 : arg11 = jenv->GetArrayLength(jarg11);
14931 0 : if (arg11 == 0)
14932 0 : arg12 = NULL;
14933 : else
14934 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
14935 : }
14936 : else
14937 : {
14938 0 : arg11 = 0;
14939 0 : arg12 = NULL;
14940 : }
14941 : }
14942 0 : arg13 = (int)jarg13;
14943 0 : arg14 = (int)jarg14;
14944 0 : arg15 = (int)jarg15;
14945 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
14946 0 : jresult = (jint)result;
14947 : {
14948 : /* %typemap(argout) (int nList, int* pList) */
14949 : }
14950 : {
14951 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
14952 : }
14953 : {
14954 : /* %typemap(freearg) (int nList, int* pList) */
14955 0 : if (arg12) {
14956 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
14957 : }
14958 : }
14959 0 : return jresult;
14960 : }
14961 :
14962 :
14963 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
14964 0 : jint jresult = 0 ;
14965 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
14966 : int arg2 ;
14967 : int arg3 ;
14968 : int arg4 ;
14969 : int arg5 ;
14970 : int arg6 ;
14971 : int arg7 ;
14972 : GDALDataType arg8 ;
14973 0 : char *arg9 = (char *) 0 ;
14974 : size_t arg10 ;
14975 : int arg11 ;
14976 0 : int *arg12 = (int *) 0 ;
14977 : int arg13 ;
14978 : int arg14 ;
14979 : CPLErr result;
14980 :
14981 : (void)jenv;
14982 : (void)jcls;
14983 : (void)jarg1_;
14984 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
14985 0 : arg2 = (int)jarg2;
14986 0 : arg3 = (int)jarg3;
14987 0 : arg4 = (int)jarg4;
14988 0 : arg5 = (int)jarg5;
14989 0 : arg6 = (int)jarg6;
14990 0 : arg7 = (int)jarg7;
14991 0 : arg8 = (GDALDataType)jarg8;
14992 : {
14993 0 : if (jarg9 == 0)
14994 : {
14995 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
14996 0 : return 0;
14997 : }
14998 :
14999 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
15000 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
15001 0 : if (arg9 == NULL)
15002 : {
15003 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15004 : "Unable to get buffer.");
15005 0 : return 0;
15006 : }
15007 : }
15008 : {
15009 : /* %typemap(in) (int nList, int* pList) */
15010 : /* check if is List */
15011 0 : if (jarg11)
15012 : {
15013 0 : arg11 = jenv->GetArrayLength(jarg11);
15014 0 : if (arg11 == 0)
15015 0 : arg12 = NULL;
15016 : else
15017 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15018 : }
15019 : else
15020 : {
15021 0 : arg11 = 0;
15022 0 : arg12 = NULL;
15023 : }
15024 : }
15025 0 : arg13 = (int)jarg13;
15026 0 : arg14 = (int)jarg14;
15027 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
15028 0 : jresult = (jint)result;
15029 : {
15030 : /* %typemap(argout) (int nList, int* pList) */
15031 : }
15032 : {
15033 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
15034 : }
15035 : {
15036 : /* %typemap(freearg) (int nList, int* pList) */
15037 0 : if (arg12) {
15038 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15039 : }
15040 : }
15041 0 : return jresult;
15042 : }
15043 :
15044 :
15045 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11, jint jarg13) {
15046 0 : jint jresult = 0 ;
15047 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15048 : int arg2 ;
15049 : int arg3 ;
15050 : int arg4 ;
15051 : int arg5 ;
15052 : int arg6 ;
15053 : int arg7 ;
15054 : GDALDataType arg8 ;
15055 0 : char *arg9 = (char *) 0 ;
15056 : size_t arg10 ;
15057 : int arg11 ;
15058 0 : int *arg12 = (int *) 0 ;
15059 : int arg13 ;
15060 : CPLErr result;
15061 :
15062 : (void)jenv;
15063 : (void)jcls;
15064 : (void)jarg1_;
15065 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15066 0 : arg2 = (int)jarg2;
15067 0 : arg3 = (int)jarg3;
15068 0 : arg4 = (int)jarg4;
15069 0 : arg5 = (int)jarg5;
15070 0 : arg6 = (int)jarg6;
15071 0 : arg7 = (int)jarg7;
15072 0 : arg8 = (GDALDataType)jarg8;
15073 : {
15074 0 : if (jarg9 == 0)
15075 : {
15076 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15077 0 : return 0;
15078 : }
15079 :
15080 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
15081 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
15082 0 : if (arg9 == NULL)
15083 : {
15084 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15085 : "Unable to get buffer.");
15086 0 : return 0;
15087 : }
15088 : }
15089 : {
15090 : /* %typemap(in) (int nList, int* pList) */
15091 : /* check if is List */
15092 0 : if (jarg11)
15093 : {
15094 0 : arg11 = jenv->GetArrayLength(jarg11);
15095 0 : if (arg11 == 0)
15096 0 : arg12 = NULL;
15097 : else
15098 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15099 : }
15100 : else
15101 : {
15102 0 : arg11 = 0;
15103 0 : arg12 = NULL;
15104 : }
15105 : }
15106 0 : arg13 = (int)jarg13;
15107 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15108 0 : jresult = (jint)result;
15109 : {
15110 : /* %typemap(argout) (int nList, int* pList) */
15111 : }
15112 : {
15113 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
15114 : }
15115 : {
15116 : /* %typemap(freearg) (int nList, int* pList) */
15117 0 : if (arg12) {
15118 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15119 : }
15120 : }
15121 0 : return jresult;
15122 : }
15123 :
15124 :
15125 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jintArray jarg11) {
15126 0 : jint jresult = 0 ;
15127 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15128 : int arg2 ;
15129 : int arg3 ;
15130 : int arg4 ;
15131 : int arg5 ;
15132 : int arg6 ;
15133 : int arg7 ;
15134 : GDALDataType arg8 ;
15135 0 : char *arg9 = (char *) 0 ;
15136 : size_t arg10 ;
15137 : int arg11 ;
15138 0 : int *arg12 = (int *) 0 ;
15139 : CPLErr result;
15140 :
15141 : (void)jenv;
15142 : (void)jcls;
15143 : (void)jarg1_;
15144 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15145 0 : arg2 = (int)jarg2;
15146 0 : arg3 = (int)jarg3;
15147 0 : arg4 = (int)jarg4;
15148 0 : arg5 = (int)jarg5;
15149 0 : arg6 = (int)jarg6;
15150 0 : arg7 = (int)jarg7;
15151 0 : arg8 = (GDALDataType)jarg8;
15152 : {
15153 0 : if (jarg9 == 0)
15154 : {
15155 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15156 0 : return 0;
15157 : }
15158 :
15159 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
15160 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
15161 0 : if (arg9 == NULL)
15162 : {
15163 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15164 : "Unable to get buffer.");
15165 0 : return 0;
15166 : }
15167 : }
15168 : {
15169 : /* %typemap(in) (int nList, int* pList) */
15170 : /* check if is List */
15171 0 : if (jarg11)
15172 : {
15173 0 : arg11 = jenv->GetArrayLength(jarg11);
15174 0 : if (arg11 == 0)
15175 0 : arg12 = NULL;
15176 : else
15177 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15178 : }
15179 : else
15180 : {
15181 0 : arg11 = 0;
15182 0 : arg12 = NULL;
15183 : }
15184 : }
15185 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15186 0 : jresult = (jint)result;
15187 : {
15188 : /* %typemap(argout) (int nList, int* pList) */
15189 : }
15190 : {
15191 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
15192 : }
15193 : {
15194 : /* %typemap(freearg) (int nList, int* pList) */
15195 0 : if (arg12) {
15196 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15197 : }
15198 : }
15199 0 : return jresult;
15200 : }
15201 :
15202 :
15203 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
15204 0 : jint jresult = 0 ;
15205 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15206 : int arg2 ;
15207 : int arg3 ;
15208 : int arg4 ;
15209 : int arg5 ;
15210 : int arg6 ;
15211 : int arg7 ;
15212 : GDALDataType arg8 ;
15213 0 : short *arg9 = (short *) 0 ;
15214 : size_t arg10 ;
15215 : int arg11 ;
15216 0 : int *arg12 = (int *) 0 ;
15217 : int arg13 ;
15218 : int arg14 ;
15219 : int arg15 ;
15220 : CPLErr result;
15221 :
15222 : (void)jenv;
15223 : (void)jcls;
15224 : (void)jarg1_;
15225 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15226 0 : arg2 = (int)jarg2;
15227 0 : arg3 = (int)jarg3;
15228 0 : arg4 = (int)jarg4;
15229 0 : arg5 = (int)jarg5;
15230 0 : arg6 = (int)jarg6;
15231 0 : arg7 = (int)jarg7;
15232 0 : arg8 = (GDALDataType)jarg8;
15233 : {
15234 0 : if (jarg9 == 0)
15235 : {
15236 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15237 0 : return 0;
15238 : }
15239 :
15240 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
15241 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
15242 0 : if (arg9 == NULL)
15243 : {
15244 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15245 : "Unable to get buffer.");
15246 0 : return 0;
15247 : }
15248 : }
15249 : {
15250 : /* %typemap(in) (int nList, int* pList) */
15251 : /* check if is List */
15252 0 : if (jarg11)
15253 : {
15254 0 : arg11 = jenv->GetArrayLength(jarg11);
15255 0 : if (arg11 == 0)
15256 0 : arg12 = NULL;
15257 : else
15258 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15259 : }
15260 : else
15261 : {
15262 0 : arg11 = 0;
15263 0 : arg12 = NULL;
15264 : }
15265 : }
15266 0 : arg13 = (int)jarg13;
15267 0 : arg14 = (int)jarg14;
15268 0 : arg15 = (int)jarg15;
15269 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
15270 0 : jresult = (jint)result;
15271 : {
15272 : /* %typemap(argout) (int nList, int* pList) */
15273 : }
15274 : {
15275 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
15276 : }
15277 : {
15278 : /* %typemap(freearg) (int nList, int* pList) */
15279 0 : if (arg12) {
15280 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15281 : }
15282 : }
15283 0 : return jresult;
15284 : }
15285 :
15286 :
15287 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
15288 0 : jint jresult = 0 ;
15289 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15290 : int arg2 ;
15291 : int arg3 ;
15292 : int arg4 ;
15293 : int arg5 ;
15294 : int arg6 ;
15295 : int arg7 ;
15296 : GDALDataType arg8 ;
15297 0 : short *arg9 = (short *) 0 ;
15298 : size_t arg10 ;
15299 : int arg11 ;
15300 0 : int *arg12 = (int *) 0 ;
15301 : int arg13 ;
15302 : int arg14 ;
15303 : CPLErr result;
15304 :
15305 : (void)jenv;
15306 : (void)jcls;
15307 : (void)jarg1_;
15308 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15309 0 : arg2 = (int)jarg2;
15310 0 : arg3 = (int)jarg3;
15311 0 : arg4 = (int)jarg4;
15312 0 : arg5 = (int)jarg5;
15313 0 : arg6 = (int)jarg6;
15314 0 : arg7 = (int)jarg7;
15315 0 : arg8 = (GDALDataType)jarg8;
15316 : {
15317 0 : if (jarg9 == 0)
15318 : {
15319 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15320 0 : return 0;
15321 : }
15322 :
15323 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
15324 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
15325 0 : if (arg9 == NULL)
15326 : {
15327 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15328 : "Unable to get buffer.");
15329 0 : return 0;
15330 : }
15331 : }
15332 : {
15333 : /* %typemap(in) (int nList, int* pList) */
15334 : /* check if is List */
15335 0 : if (jarg11)
15336 : {
15337 0 : arg11 = jenv->GetArrayLength(jarg11);
15338 0 : if (arg11 == 0)
15339 0 : arg12 = NULL;
15340 : else
15341 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15342 : }
15343 : else
15344 : {
15345 0 : arg11 = 0;
15346 0 : arg12 = NULL;
15347 : }
15348 : }
15349 0 : arg13 = (int)jarg13;
15350 0 : arg14 = (int)jarg14;
15351 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
15352 0 : jresult = (jint)result;
15353 : {
15354 : /* %typemap(argout) (int nList, int* pList) */
15355 : }
15356 : {
15357 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
15358 : }
15359 : {
15360 : /* %typemap(freearg) (int nList, int* pList) */
15361 0 : if (arg12) {
15362 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15363 : }
15364 : }
15365 0 : return jresult;
15366 : }
15367 :
15368 :
15369 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11, jint jarg13) {
15370 0 : jint jresult = 0 ;
15371 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15372 : int arg2 ;
15373 : int arg3 ;
15374 : int arg4 ;
15375 : int arg5 ;
15376 : int arg6 ;
15377 : int arg7 ;
15378 : GDALDataType arg8 ;
15379 0 : short *arg9 = (short *) 0 ;
15380 : size_t arg10 ;
15381 : int arg11 ;
15382 0 : int *arg12 = (int *) 0 ;
15383 : int arg13 ;
15384 : CPLErr result;
15385 :
15386 : (void)jenv;
15387 : (void)jcls;
15388 : (void)jarg1_;
15389 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15390 0 : arg2 = (int)jarg2;
15391 0 : arg3 = (int)jarg3;
15392 0 : arg4 = (int)jarg4;
15393 0 : arg5 = (int)jarg5;
15394 0 : arg6 = (int)jarg6;
15395 0 : arg7 = (int)jarg7;
15396 0 : arg8 = (GDALDataType)jarg8;
15397 : {
15398 0 : if (jarg9 == 0)
15399 : {
15400 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15401 0 : return 0;
15402 : }
15403 :
15404 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
15405 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
15406 0 : if (arg9 == NULL)
15407 : {
15408 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15409 : "Unable to get buffer.");
15410 0 : return 0;
15411 : }
15412 : }
15413 : {
15414 : /* %typemap(in) (int nList, int* pList) */
15415 : /* check if is List */
15416 0 : if (jarg11)
15417 : {
15418 0 : arg11 = jenv->GetArrayLength(jarg11);
15419 0 : if (arg11 == 0)
15420 0 : arg12 = NULL;
15421 : else
15422 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15423 : }
15424 : else
15425 : {
15426 0 : arg11 = 0;
15427 0 : arg12 = NULL;
15428 : }
15429 : }
15430 0 : arg13 = (int)jarg13;
15431 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15432 0 : jresult = (jint)result;
15433 : {
15434 : /* %typemap(argout) (int nList, int* pList) */
15435 : }
15436 : {
15437 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
15438 : }
15439 : {
15440 : /* %typemap(freearg) (int nList, int* pList) */
15441 0 : if (arg12) {
15442 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15443 : }
15444 : }
15445 0 : return jresult;
15446 : }
15447 :
15448 :
15449 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jintArray jarg11) {
15450 0 : jint jresult = 0 ;
15451 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15452 : int arg2 ;
15453 : int arg3 ;
15454 : int arg4 ;
15455 : int arg5 ;
15456 : int arg6 ;
15457 : int arg7 ;
15458 : GDALDataType arg8 ;
15459 0 : short *arg9 = (short *) 0 ;
15460 : size_t arg10 ;
15461 : int arg11 ;
15462 0 : int *arg12 = (int *) 0 ;
15463 : CPLErr result;
15464 :
15465 : (void)jenv;
15466 : (void)jcls;
15467 : (void)jarg1_;
15468 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15469 0 : arg2 = (int)jarg2;
15470 0 : arg3 = (int)jarg3;
15471 0 : arg4 = (int)jarg4;
15472 0 : arg5 = (int)jarg5;
15473 0 : arg6 = (int)jarg6;
15474 0 : arg7 = (int)jarg7;
15475 0 : arg8 = (GDALDataType)jarg8;
15476 : {
15477 0 : if (jarg9 == 0)
15478 : {
15479 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15480 0 : return 0;
15481 : }
15482 :
15483 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
15484 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
15485 0 : if (arg9 == NULL)
15486 : {
15487 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15488 : "Unable to get buffer.");
15489 0 : return 0;
15490 : }
15491 : }
15492 : {
15493 : /* %typemap(in) (int nList, int* pList) */
15494 : /* check if is List */
15495 0 : if (jarg11)
15496 : {
15497 0 : arg11 = jenv->GetArrayLength(jarg11);
15498 0 : if (arg11 == 0)
15499 0 : arg12 = NULL;
15500 : else
15501 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15502 : }
15503 : else
15504 : {
15505 0 : arg11 = 0;
15506 0 : arg12 = NULL;
15507 : }
15508 : }
15509 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15510 0 : jresult = (jint)result;
15511 : {
15512 : /* %typemap(argout) (int nList, int* pList) */
15513 : }
15514 : {
15515 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
15516 : }
15517 : {
15518 : /* %typemap(freearg) (int nList, int* pList) */
15519 0 : if (arg12) {
15520 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15521 : }
15522 : }
15523 0 : return jresult;
15524 : }
15525 :
15526 :
15527 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
15528 0 : jint jresult = 0 ;
15529 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15530 : int arg2 ;
15531 : int arg3 ;
15532 : int arg4 ;
15533 : int arg5 ;
15534 : int arg6 ;
15535 : int arg7 ;
15536 : GDALDataType arg8 ;
15537 0 : int *arg9 = (int *) 0 ;
15538 : size_t arg10 ;
15539 : int arg11 ;
15540 0 : int *arg12 = (int *) 0 ;
15541 : int arg13 ;
15542 : int arg14 ;
15543 : int arg15 ;
15544 : CPLErr result;
15545 :
15546 : (void)jenv;
15547 : (void)jcls;
15548 : (void)jarg1_;
15549 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15550 0 : arg2 = (int)jarg2;
15551 0 : arg3 = (int)jarg3;
15552 0 : arg4 = (int)jarg4;
15553 0 : arg5 = (int)jarg5;
15554 0 : arg6 = (int)jarg6;
15555 0 : arg7 = (int)jarg7;
15556 0 : arg8 = (GDALDataType)jarg8;
15557 : {
15558 0 : if (jarg9 == 0)
15559 : {
15560 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15561 0 : return 0;
15562 : }
15563 :
15564 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
15565 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
15566 0 : if (arg9 == NULL)
15567 : {
15568 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15569 : "Unable to get buffer.");
15570 0 : return 0;
15571 : }
15572 : }
15573 : {
15574 : /* %typemap(in) (int nList, int* pList) */
15575 : /* check if is List */
15576 0 : if (jarg11)
15577 : {
15578 0 : arg11 = jenv->GetArrayLength(jarg11);
15579 0 : if (arg11 == 0)
15580 0 : arg12 = NULL;
15581 : else
15582 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15583 : }
15584 : else
15585 : {
15586 0 : arg11 = 0;
15587 0 : arg12 = NULL;
15588 : }
15589 : }
15590 0 : arg13 = (int)jarg13;
15591 0 : arg14 = (int)jarg14;
15592 0 : arg15 = (int)jarg15;
15593 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
15594 0 : jresult = (jint)result;
15595 : {
15596 : /* %typemap(argout) (int nList, int* pList) */
15597 : }
15598 : {
15599 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
15600 : }
15601 : {
15602 : /* %typemap(freearg) (int nList, int* pList) */
15603 0 : if (arg12) {
15604 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15605 : }
15606 : }
15607 0 : return jresult;
15608 : }
15609 :
15610 :
15611 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
15612 0 : jint jresult = 0 ;
15613 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15614 : int arg2 ;
15615 : int arg3 ;
15616 : int arg4 ;
15617 : int arg5 ;
15618 : int arg6 ;
15619 : int arg7 ;
15620 : GDALDataType arg8 ;
15621 0 : int *arg9 = (int *) 0 ;
15622 : size_t arg10 ;
15623 : int arg11 ;
15624 0 : int *arg12 = (int *) 0 ;
15625 : int arg13 ;
15626 : int arg14 ;
15627 : CPLErr result;
15628 :
15629 : (void)jenv;
15630 : (void)jcls;
15631 : (void)jarg1_;
15632 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15633 0 : arg2 = (int)jarg2;
15634 0 : arg3 = (int)jarg3;
15635 0 : arg4 = (int)jarg4;
15636 0 : arg5 = (int)jarg5;
15637 0 : arg6 = (int)jarg6;
15638 0 : arg7 = (int)jarg7;
15639 0 : arg8 = (GDALDataType)jarg8;
15640 : {
15641 0 : if (jarg9 == 0)
15642 : {
15643 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15644 0 : return 0;
15645 : }
15646 :
15647 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
15648 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
15649 0 : if (arg9 == NULL)
15650 : {
15651 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15652 : "Unable to get buffer.");
15653 0 : return 0;
15654 : }
15655 : }
15656 : {
15657 : /* %typemap(in) (int nList, int* pList) */
15658 : /* check if is List */
15659 0 : if (jarg11)
15660 : {
15661 0 : arg11 = jenv->GetArrayLength(jarg11);
15662 0 : if (arg11 == 0)
15663 0 : arg12 = NULL;
15664 : else
15665 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15666 : }
15667 : else
15668 : {
15669 0 : arg11 = 0;
15670 0 : arg12 = NULL;
15671 : }
15672 : }
15673 0 : arg13 = (int)jarg13;
15674 0 : arg14 = (int)jarg14;
15675 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
15676 0 : jresult = (jint)result;
15677 : {
15678 : /* %typemap(argout) (int nList, int* pList) */
15679 : }
15680 : {
15681 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
15682 : }
15683 : {
15684 : /* %typemap(freearg) (int nList, int* pList) */
15685 0 : if (arg12) {
15686 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15687 : }
15688 : }
15689 0 : return jresult;
15690 : }
15691 :
15692 :
15693 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11, jint jarg13) {
15694 0 : jint jresult = 0 ;
15695 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15696 : int arg2 ;
15697 : int arg3 ;
15698 : int arg4 ;
15699 : int arg5 ;
15700 : int arg6 ;
15701 : int arg7 ;
15702 : GDALDataType arg8 ;
15703 0 : int *arg9 = (int *) 0 ;
15704 : size_t arg10 ;
15705 : int arg11 ;
15706 0 : int *arg12 = (int *) 0 ;
15707 : int arg13 ;
15708 : CPLErr result;
15709 :
15710 : (void)jenv;
15711 : (void)jcls;
15712 : (void)jarg1_;
15713 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15714 0 : arg2 = (int)jarg2;
15715 0 : arg3 = (int)jarg3;
15716 0 : arg4 = (int)jarg4;
15717 0 : arg5 = (int)jarg5;
15718 0 : arg6 = (int)jarg6;
15719 0 : arg7 = (int)jarg7;
15720 0 : arg8 = (GDALDataType)jarg8;
15721 : {
15722 0 : if (jarg9 == 0)
15723 : {
15724 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15725 0 : return 0;
15726 : }
15727 :
15728 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
15729 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
15730 0 : if (arg9 == NULL)
15731 : {
15732 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15733 : "Unable to get buffer.");
15734 0 : return 0;
15735 : }
15736 : }
15737 : {
15738 : /* %typemap(in) (int nList, int* pList) */
15739 : /* check if is List */
15740 0 : if (jarg11)
15741 : {
15742 0 : arg11 = jenv->GetArrayLength(jarg11);
15743 0 : if (arg11 == 0)
15744 0 : arg12 = NULL;
15745 : else
15746 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15747 : }
15748 : else
15749 : {
15750 0 : arg11 = 0;
15751 0 : arg12 = NULL;
15752 : }
15753 : }
15754 0 : arg13 = (int)jarg13;
15755 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
15756 0 : jresult = (jint)result;
15757 : {
15758 : /* %typemap(argout) (int nList, int* pList) */
15759 : }
15760 : {
15761 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
15762 : }
15763 : {
15764 : /* %typemap(freearg) (int nList, int* pList) */
15765 0 : if (arg12) {
15766 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15767 : }
15768 : }
15769 0 : return jresult;
15770 : }
15771 :
15772 :
15773 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_111(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jintArray jarg11) {
15774 0 : jint jresult = 0 ;
15775 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15776 : int arg2 ;
15777 : int arg3 ;
15778 : int arg4 ;
15779 : int arg5 ;
15780 : int arg6 ;
15781 : int arg7 ;
15782 : GDALDataType arg8 ;
15783 0 : int *arg9 = (int *) 0 ;
15784 : size_t arg10 ;
15785 : int arg11 ;
15786 0 : int *arg12 = (int *) 0 ;
15787 : CPLErr result;
15788 :
15789 : (void)jenv;
15790 : (void)jcls;
15791 : (void)jarg1_;
15792 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15793 0 : arg2 = (int)jarg2;
15794 0 : arg3 = (int)jarg3;
15795 0 : arg4 = (int)jarg4;
15796 0 : arg5 = (int)jarg5;
15797 0 : arg6 = (int)jarg6;
15798 0 : arg7 = (int)jarg7;
15799 0 : arg8 = (GDALDataType)jarg8;
15800 : {
15801 0 : if (jarg9 == 0)
15802 : {
15803 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15804 0 : return 0;
15805 : }
15806 :
15807 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
15808 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
15809 0 : if (arg9 == NULL)
15810 : {
15811 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15812 : "Unable to get buffer.");
15813 0 : return 0;
15814 : }
15815 : }
15816 : {
15817 : /* %typemap(in) (int nList, int* pList) */
15818 : /* check if is List */
15819 0 : if (jarg11)
15820 : {
15821 0 : arg11 = jenv->GetArrayLength(jarg11);
15822 0 : if (arg11 == 0)
15823 0 : arg12 = NULL;
15824 : else
15825 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15826 : }
15827 : else
15828 : {
15829 0 : arg11 = 0;
15830 0 : arg12 = NULL;
15831 : }
15832 : }
15833 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_8(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
15834 0 : jresult = (jint)result;
15835 : {
15836 : /* %typemap(argout) (int nList, int* pList) */
15837 : }
15838 : {
15839 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
15840 : }
15841 : {
15842 : /* %typemap(freearg) (int nList, int* pList) */
15843 0 : if (arg12) {
15844 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15845 : }
15846 : }
15847 0 : return jresult;
15848 : }
15849 :
15850 :
15851 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_112(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
15852 0 : jint jresult = 0 ;
15853 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15854 : int arg2 ;
15855 : int arg3 ;
15856 : int arg4 ;
15857 : int arg5 ;
15858 : int arg6 ;
15859 : int arg7 ;
15860 : GDALDataType arg8 ;
15861 0 : int64_t *arg9 = (int64_t *) 0 ;
15862 : size_t arg10 ;
15863 : int arg11 ;
15864 0 : int *arg12 = (int *) 0 ;
15865 : int arg13 ;
15866 : int arg14 ;
15867 : int arg15 ;
15868 : CPLErr result;
15869 :
15870 : (void)jenv;
15871 : (void)jcls;
15872 : (void)jarg1_;
15873 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15874 0 : arg2 = (int)jarg2;
15875 0 : arg3 = (int)jarg3;
15876 0 : arg4 = (int)jarg4;
15877 0 : arg5 = (int)jarg5;
15878 0 : arg6 = (int)jarg6;
15879 0 : arg7 = (int)jarg7;
15880 0 : arg8 = (GDALDataType)jarg8;
15881 : {
15882 0 : if (jarg9 == 0)
15883 : {
15884 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15885 0 : return 0;
15886 : }
15887 :
15888 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
15889 0 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
15890 0 : if (arg9 == NULL)
15891 : {
15892 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15893 : "Unable to get buffer.");
15894 0 : return 0;
15895 : }
15896 : }
15897 : {
15898 : /* %typemap(in) (int nList, int* pList) */
15899 : /* check if is List */
15900 0 : if (jarg11)
15901 : {
15902 0 : arg11 = jenv->GetArrayLength(jarg11);
15903 0 : if (arg11 == 0)
15904 0 : arg12 = NULL;
15905 : else
15906 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15907 : }
15908 : else
15909 : {
15910 0 : arg11 = 0;
15911 0 : arg12 = NULL;
15912 : }
15913 : }
15914 0 : arg13 = (int)jarg13;
15915 0 : arg14 = (int)jarg14;
15916 0 : arg15 = (int)jarg15;
15917 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
15918 0 : jresult = (jint)result;
15919 : {
15920 : /* %typemap(argout) (int nList, int* pList) */
15921 : }
15922 : {
15923 0 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
15924 : }
15925 : {
15926 : /* %typemap(freearg) (int nList, int* pList) */
15927 0 : if (arg12) {
15928 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
15929 : }
15930 : }
15931 0 : return jresult;
15932 : }
15933 :
15934 :
15935 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_113(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
15936 0 : jint jresult = 0 ;
15937 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
15938 : int arg2 ;
15939 : int arg3 ;
15940 : int arg4 ;
15941 : int arg5 ;
15942 : int arg6 ;
15943 : int arg7 ;
15944 : GDALDataType arg8 ;
15945 0 : int64_t *arg9 = (int64_t *) 0 ;
15946 : size_t arg10 ;
15947 : int arg11 ;
15948 0 : int *arg12 = (int *) 0 ;
15949 : int arg13 ;
15950 : int arg14 ;
15951 : CPLErr result;
15952 :
15953 : (void)jenv;
15954 : (void)jcls;
15955 : (void)jarg1_;
15956 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
15957 0 : arg2 = (int)jarg2;
15958 0 : arg3 = (int)jarg3;
15959 0 : arg4 = (int)jarg4;
15960 0 : arg5 = (int)jarg5;
15961 0 : arg6 = (int)jarg6;
15962 0 : arg7 = (int)jarg7;
15963 0 : arg8 = (GDALDataType)jarg8;
15964 : {
15965 0 : if (jarg9 == 0)
15966 : {
15967 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
15968 0 : return 0;
15969 : }
15970 :
15971 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
15972 0 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
15973 0 : if (arg9 == NULL)
15974 : {
15975 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
15976 : "Unable to get buffer.");
15977 0 : return 0;
15978 : }
15979 : }
15980 : {
15981 : /* %typemap(in) (int nList, int* pList) */
15982 : /* check if is List */
15983 0 : if (jarg11)
15984 : {
15985 0 : arg11 = jenv->GetArrayLength(jarg11);
15986 0 : if (arg11 == 0)
15987 0 : arg12 = NULL;
15988 : else
15989 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
15990 : }
15991 : else
15992 : {
15993 0 : arg11 = 0;
15994 0 : arg12 = NULL;
15995 : }
15996 : }
15997 0 : arg13 = (int)jarg13;
15998 0 : arg14 = (int)jarg14;
15999 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
16000 0 : jresult = (jint)result;
16001 : {
16002 : /* %typemap(argout) (int nList, int* pList) */
16003 : }
16004 : {
16005 0 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
16006 : }
16007 : {
16008 : /* %typemap(freearg) (int nList, int* pList) */
16009 0 : if (arg12) {
16010 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16011 : }
16012 : }
16013 0 : return jresult;
16014 : }
16015 :
16016 :
16017 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_114(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11, jint jarg13) {
16018 0 : jint jresult = 0 ;
16019 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16020 : int arg2 ;
16021 : int arg3 ;
16022 : int arg4 ;
16023 : int arg5 ;
16024 : int arg6 ;
16025 : int arg7 ;
16026 : GDALDataType arg8 ;
16027 0 : int64_t *arg9 = (int64_t *) 0 ;
16028 : size_t arg10 ;
16029 : int arg11 ;
16030 0 : int *arg12 = (int *) 0 ;
16031 : int arg13 ;
16032 : CPLErr result;
16033 :
16034 : (void)jenv;
16035 : (void)jcls;
16036 : (void)jarg1_;
16037 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16038 0 : arg2 = (int)jarg2;
16039 0 : arg3 = (int)jarg3;
16040 0 : arg4 = (int)jarg4;
16041 0 : arg5 = (int)jarg5;
16042 0 : arg6 = (int)jarg6;
16043 0 : arg7 = (int)jarg7;
16044 0 : arg8 = (GDALDataType)jarg8;
16045 : {
16046 0 : if (jarg9 == 0)
16047 : {
16048 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16049 0 : return 0;
16050 : }
16051 :
16052 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
16053 0 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
16054 0 : if (arg9 == NULL)
16055 : {
16056 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16057 : "Unable to get buffer.");
16058 0 : return 0;
16059 : }
16060 : }
16061 : {
16062 : /* %typemap(in) (int nList, int* pList) */
16063 : /* check if is List */
16064 0 : if (jarg11)
16065 : {
16066 0 : arg11 = jenv->GetArrayLength(jarg11);
16067 0 : if (arg11 == 0)
16068 0 : arg12 = NULL;
16069 : else
16070 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16071 : }
16072 : else
16073 : {
16074 0 : arg11 = 0;
16075 0 : arg12 = NULL;
16076 : }
16077 : }
16078 0 : arg13 = (int)jarg13;
16079 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
16080 0 : jresult = (jint)result;
16081 : {
16082 : /* %typemap(argout) (int nList, int* pList) */
16083 : }
16084 : {
16085 0 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
16086 : }
16087 : {
16088 : /* %typemap(freearg) (int nList, int* pList) */
16089 0 : if (arg12) {
16090 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16091 : }
16092 : }
16093 0 : return jresult;
16094 : }
16095 :
16096 :
16097 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_115(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jintArray jarg11) {
16098 1 : jint jresult = 0 ;
16099 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16100 : int arg2 ;
16101 : int arg3 ;
16102 : int arg4 ;
16103 : int arg5 ;
16104 : int arg6 ;
16105 : int arg7 ;
16106 : GDALDataType arg8 ;
16107 1 : int64_t *arg9 = (int64_t *) 0 ;
16108 : size_t arg10 ;
16109 : int arg11 ;
16110 1 : int *arg12 = (int *) 0 ;
16111 : CPLErr result;
16112 :
16113 : (void)jenv;
16114 : (void)jcls;
16115 : (void)jarg1_;
16116 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
16117 1 : arg2 = (int)jarg2;
16118 1 : arg3 = (int)jarg3;
16119 1 : arg4 = (int)jarg4;
16120 1 : arg5 = (int)jarg5;
16121 1 : arg6 = (int)jarg6;
16122 1 : arg7 = (int)jarg7;
16123 1 : arg8 = (GDALDataType)jarg8;
16124 : {
16125 1 : if (jarg9 == 0)
16126 : {
16127 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16128 0 : return 0;
16129 : }
16130 :
16131 1 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
16132 1 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
16133 1 : if (arg9 == NULL)
16134 : {
16135 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16136 : "Unable to get buffer.");
16137 0 : return 0;
16138 : }
16139 : }
16140 : {
16141 : /* %typemap(in) (int nList, int* pList) */
16142 : /* check if is List */
16143 1 : if (jarg11)
16144 : {
16145 1 : arg11 = jenv->GetArrayLength(jarg11);
16146 1 : if (arg11 == 0)
16147 0 : arg12 = NULL;
16148 : else
16149 1 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16150 : }
16151 : else
16152 : {
16153 0 : arg11 = 0;
16154 0 : arg12 = NULL;
16155 : }
16156 : }
16157 1 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16158 1 : jresult = (jint)result;
16159 : {
16160 : /* %typemap(argout) (int nList, int* pList) */
16161 : }
16162 : {
16163 1 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
16164 : }
16165 : {
16166 : /* %typemap(freearg) (int nList, int* pList) */
16167 1 : if (arg12) {
16168 1 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16169 : }
16170 : }
16171 1 : return jresult;
16172 : }
16173 :
16174 :
16175 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_116(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
16176 0 : jint jresult = 0 ;
16177 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16178 : int arg2 ;
16179 : int arg3 ;
16180 : int arg4 ;
16181 : int arg5 ;
16182 : int arg6 ;
16183 : int arg7 ;
16184 : GDALDataType arg8 ;
16185 0 : float *arg9 = (float *) 0 ;
16186 : size_t arg10 ;
16187 : int arg11 ;
16188 0 : int *arg12 = (int *) 0 ;
16189 : int arg13 ;
16190 : int arg14 ;
16191 : int arg15 ;
16192 : CPLErr result;
16193 :
16194 : (void)jenv;
16195 : (void)jcls;
16196 : (void)jarg1_;
16197 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16198 0 : arg2 = (int)jarg2;
16199 0 : arg3 = (int)jarg3;
16200 0 : arg4 = (int)jarg4;
16201 0 : arg5 = (int)jarg5;
16202 0 : arg6 = (int)jarg6;
16203 0 : arg7 = (int)jarg7;
16204 0 : arg8 = (GDALDataType)jarg8;
16205 : {
16206 0 : if (jarg9 == 0)
16207 : {
16208 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16209 0 : return 0;
16210 : }
16211 :
16212 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
16213 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
16214 0 : if (arg9 == NULL)
16215 : {
16216 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16217 : "Unable to get buffer.");
16218 0 : return 0;
16219 : }
16220 : }
16221 : {
16222 : /* %typemap(in) (int nList, int* pList) */
16223 : /* check if is List */
16224 0 : if (jarg11)
16225 : {
16226 0 : arg11 = jenv->GetArrayLength(jarg11);
16227 0 : if (arg11 == 0)
16228 0 : arg12 = NULL;
16229 : else
16230 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16231 : }
16232 : else
16233 : {
16234 0 : arg11 = 0;
16235 0 : arg12 = NULL;
16236 : }
16237 : }
16238 0 : arg13 = (int)jarg13;
16239 0 : arg14 = (int)jarg14;
16240 0 : arg15 = (int)jarg15;
16241 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
16242 0 : jresult = (jint)result;
16243 : {
16244 : /* %typemap(argout) (int nList, int* pList) */
16245 : }
16246 : {
16247 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
16248 : }
16249 : {
16250 : /* %typemap(freearg) (int nList, int* pList) */
16251 0 : if (arg12) {
16252 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16253 : }
16254 : }
16255 0 : return jresult;
16256 : }
16257 :
16258 :
16259 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_117(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
16260 0 : jint jresult = 0 ;
16261 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16262 : int arg2 ;
16263 : int arg3 ;
16264 : int arg4 ;
16265 : int arg5 ;
16266 : int arg6 ;
16267 : int arg7 ;
16268 : GDALDataType arg8 ;
16269 0 : float *arg9 = (float *) 0 ;
16270 : size_t arg10 ;
16271 : int arg11 ;
16272 0 : int *arg12 = (int *) 0 ;
16273 : int arg13 ;
16274 : int arg14 ;
16275 : CPLErr result;
16276 :
16277 : (void)jenv;
16278 : (void)jcls;
16279 : (void)jarg1_;
16280 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16281 0 : arg2 = (int)jarg2;
16282 0 : arg3 = (int)jarg3;
16283 0 : arg4 = (int)jarg4;
16284 0 : arg5 = (int)jarg5;
16285 0 : arg6 = (int)jarg6;
16286 0 : arg7 = (int)jarg7;
16287 0 : arg8 = (GDALDataType)jarg8;
16288 : {
16289 0 : if (jarg9 == 0)
16290 : {
16291 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16292 0 : return 0;
16293 : }
16294 :
16295 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
16296 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
16297 0 : if (arg9 == NULL)
16298 : {
16299 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16300 : "Unable to get buffer.");
16301 0 : return 0;
16302 : }
16303 : }
16304 : {
16305 : /* %typemap(in) (int nList, int* pList) */
16306 : /* check if is List */
16307 0 : if (jarg11)
16308 : {
16309 0 : arg11 = jenv->GetArrayLength(jarg11);
16310 0 : if (arg11 == 0)
16311 0 : arg12 = NULL;
16312 : else
16313 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16314 : }
16315 : else
16316 : {
16317 0 : arg11 = 0;
16318 0 : arg12 = NULL;
16319 : }
16320 : }
16321 0 : arg13 = (int)jarg13;
16322 0 : arg14 = (int)jarg14;
16323 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
16324 0 : jresult = (jint)result;
16325 : {
16326 : /* %typemap(argout) (int nList, int* pList) */
16327 : }
16328 : {
16329 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
16330 : }
16331 : {
16332 : /* %typemap(freearg) (int nList, int* pList) */
16333 0 : if (arg12) {
16334 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16335 : }
16336 : }
16337 0 : return jresult;
16338 : }
16339 :
16340 :
16341 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_118(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11, jint jarg13) {
16342 0 : jint jresult = 0 ;
16343 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16344 : int arg2 ;
16345 : int arg3 ;
16346 : int arg4 ;
16347 : int arg5 ;
16348 : int arg6 ;
16349 : int arg7 ;
16350 : GDALDataType arg8 ;
16351 0 : float *arg9 = (float *) 0 ;
16352 : size_t arg10 ;
16353 : int arg11 ;
16354 0 : int *arg12 = (int *) 0 ;
16355 : int arg13 ;
16356 : CPLErr result;
16357 :
16358 : (void)jenv;
16359 : (void)jcls;
16360 : (void)jarg1_;
16361 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16362 0 : arg2 = (int)jarg2;
16363 0 : arg3 = (int)jarg3;
16364 0 : arg4 = (int)jarg4;
16365 0 : arg5 = (int)jarg5;
16366 0 : arg6 = (int)jarg6;
16367 0 : arg7 = (int)jarg7;
16368 0 : arg8 = (GDALDataType)jarg8;
16369 : {
16370 0 : if (jarg9 == 0)
16371 : {
16372 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16373 0 : return 0;
16374 : }
16375 :
16376 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
16377 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
16378 0 : if (arg9 == NULL)
16379 : {
16380 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16381 : "Unable to get buffer.");
16382 0 : return 0;
16383 : }
16384 : }
16385 : {
16386 : /* %typemap(in) (int nList, int* pList) */
16387 : /* check if is List */
16388 0 : if (jarg11)
16389 : {
16390 0 : arg11 = jenv->GetArrayLength(jarg11);
16391 0 : if (arg11 == 0)
16392 0 : arg12 = NULL;
16393 : else
16394 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16395 : }
16396 : else
16397 : {
16398 0 : arg11 = 0;
16399 0 : arg12 = NULL;
16400 : }
16401 : }
16402 0 : arg13 = (int)jarg13;
16403 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
16404 0 : jresult = (jint)result;
16405 : {
16406 : /* %typemap(argout) (int nList, int* pList) */
16407 : }
16408 : {
16409 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
16410 : }
16411 : {
16412 : /* %typemap(freearg) (int nList, int* pList) */
16413 0 : if (arg12) {
16414 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16415 : }
16416 : }
16417 0 : return jresult;
16418 : }
16419 :
16420 :
16421 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_119(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jintArray jarg11) {
16422 0 : jint jresult = 0 ;
16423 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16424 : int arg2 ;
16425 : int arg3 ;
16426 : int arg4 ;
16427 : int arg5 ;
16428 : int arg6 ;
16429 : int arg7 ;
16430 : GDALDataType arg8 ;
16431 0 : float *arg9 = (float *) 0 ;
16432 : size_t arg10 ;
16433 : int arg11 ;
16434 0 : int *arg12 = (int *) 0 ;
16435 : CPLErr result;
16436 :
16437 : (void)jenv;
16438 : (void)jcls;
16439 : (void)jarg1_;
16440 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16441 0 : arg2 = (int)jarg2;
16442 0 : arg3 = (int)jarg3;
16443 0 : arg4 = (int)jarg4;
16444 0 : arg5 = (int)jarg5;
16445 0 : arg6 = (int)jarg6;
16446 0 : arg7 = (int)jarg7;
16447 0 : arg8 = (GDALDataType)jarg8;
16448 : {
16449 0 : if (jarg9 == 0)
16450 : {
16451 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16452 0 : return 0;
16453 : }
16454 :
16455 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
16456 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
16457 0 : if (arg9 == NULL)
16458 : {
16459 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16460 : "Unable to get buffer.");
16461 0 : return 0;
16462 : }
16463 : }
16464 : {
16465 : /* %typemap(in) (int nList, int* pList) */
16466 : /* check if is List */
16467 0 : if (jarg11)
16468 : {
16469 0 : arg11 = jenv->GetArrayLength(jarg11);
16470 0 : if (arg11 == 0)
16471 0 : arg12 = NULL;
16472 : else
16473 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16474 : }
16475 : else
16476 : {
16477 0 : arg11 = 0;
16478 0 : arg12 = NULL;
16479 : }
16480 : }
16481 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_16(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16482 0 : jresult = (jint)result;
16483 : {
16484 : /* %typemap(argout) (int nList, int* pList) */
16485 : }
16486 : {
16487 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
16488 : }
16489 : {
16490 : /* %typemap(freearg) (int nList, int* pList) */
16491 0 : if (arg12) {
16492 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16493 : }
16494 : }
16495 0 : return jresult;
16496 : }
16497 :
16498 :
16499 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_120(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13, jint jarg14, jint jarg15) {
16500 0 : jint jresult = 0 ;
16501 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16502 : int arg2 ;
16503 : int arg3 ;
16504 : int arg4 ;
16505 : int arg5 ;
16506 : int arg6 ;
16507 : int arg7 ;
16508 : GDALDataType arg8 ;
16509 0 : double *arg9 = (double *) 0 ;
16510 : size_t arg10 ;
16511 : int arg11 ;
16512 0 : int *arg12 = (int *) 0 ;
16513 : int arg13 ;
16514 : int arg14 ;
16515 : int arg15 ;
16516 : CPLErr result;
16517 :
16518 : (void)jenv;
16519 : (void)jcls;
16520 : (void)jarg1_;
16521 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16522 0 : arg2 = (int)jarg2;
16523 0 : arg3 = (int)jarg3;
16524 0 : arg4 = (int)jarg4;
16525 0 : arg5 = (int)jarg5;
16526 0 : arg6 = (int)jarg6;
16527 0 : arg7 = (int)jarg7;
16528 0 : arg8 = (GDALDataType)jarg8;
16529 : {
16530 0 : if (jarg9 == 0)
16531 : {
16532 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16533 0 : return 0;
16534 : }
16535 :
16536 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
16537 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
16538 0 : if (arg9 == NULL)
16539 : {
16540 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16541 : "Unable to get buffer.");
16542 0 : return 0;
16543 : }
16544 : }
16545 : {
16546 : /* %typemap(in) (int nList, int* pList) */
16547 : /* check if is List */
16548 0 : if (jarg11)
16549 : {
16550 0 : arg11 = jenv->GetArrayLength(jarg11);
16551 0 : if (arg11 == 0)
16552 0 : arg12 = NULL;
16553 : else
16554 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16555 : }
16556 : else
16557 : {
16558 0 : arg11 = 0;
16559 0 : arg12 = NULL;
16560 : }
16561 : }
16562 0 : arg13 = (int)jarg13;
16563 0 : arg14 = (int)jarg14;
16564 0 : arg15 = (int)jarg15;
16565 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
16566 0 : jresult = (jint)result;
16567 : {
16568 : /* %typemap(argout) (int nList, int* pList) */
16569 : }
16570 : {
16571 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
16572 : }
16573 : {
16574 : /* %typemap(freearg) (int nList, int* pList) */
16575 0 : if (arg12) {
16576 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16577 : }
16578 : }
16579 0 : return jresult;
16580 : }
16581 :
16582 :
16583 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_121(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13, jint jarg14) {
16584 0 : jint jresult = 0 ;
16585 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16586 : int arg2 ;
16587 : int arg3 ;
16588 : int arg4 ;
16589 : int arg5 ;
16590 : int arg6 ;
16591 : int arg7 ;
16592 : GDALDataType arg8 ;
16593 0 : double *arg9 = (double *) 0 ;
16594 : size_t arg10 ;
16595 : int arg11 ;
16596 0 : int *arg12 = (int *) 0 ;
16597 : int arg13 ;
16598 : int arg14 ;
16599 : CPLErr result;
16600 :
16601 : (void)jenv;
16602 : (void)jcls;
16603 : (void)jarg1_;
16604 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16605 0 : arg2 = (int)jarg2;
16606 0 : arg3 = (int)jarg3;
16607 0 : arg4 = (int)jarg4;
16608 0 : arg5 = (int)jarg5;
16609 0 : arg6 = (int)jarg6;
16610 0 : arg7 = (int)jarg7;
16611 0 : arg8 = (GDALDataType)jarg8;
16612 : {
16613 0 : if (jarg9 == 0)
16614 : {
16615 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16616 0 : return 0;
16617 : }
16618 :
16619 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
16620 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
16621 0 : if (arg9 == NULL)
16622 : {
16623 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16624 : "Unable to get buffer.");
16625 0 : return 0;
16626 : }
16627 : }
16628 : {
16629 : /* %typemap(in) (int nList, int* pList) */
16630 : /* check if is List */
16631 0 : if (jarg11)
16632 : {
16633 0 : arg11 = jenv->GetArrayLength(jarg11);
16634 0 : if (arg11 == 0)
16635 0 : arg12 = NULL;
16636 : else
16637 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16638 : }
16639 : else
16640 : {
16641 0 : arg11 = 0;
16642 0 : arg12 = NULL;
16643 : }
16644 : }
16645 0 : arg13 = (int)jarg13;
16646 0 : arg14 = (int)jarg14;
16647 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
16648 0 : jresult = (jint)result;
16649 : {
16650 : /* %typemap(argout) (int nList, int* pList) */
16651 : }
16652 : {
16653 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
16654 : }
16655 : {
16656 : /* %typemap(freearg) (int nList, int* pList) */
16657 0 : if (arg12) {
16658 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16659 : }
16660 : }
16661 0 : return jresult;
16662 : }
16663 :
16664 :
16665 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_122(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11, jint jarg13) {
16666 0 : jint jresult = 0 ;
16667 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16668 : int arg2 ;
16669 : int arg3 ;
16670 : int arg4 ;
16671 : int arg5 ;
16672 : int arg6 ;
16673 : int arg7 ;
16674 : GDALDataType arg8 ;
16675 0 : double *arg9 = (double *) 0 ;
16676 : size_t arg10 ;
16677 : int arg11 ;
16678 0 : int *arg12 = (int *) 0 ;
16679 : int arg13 ;
16680 : CPLErr result;
16681 :
16682 : (void)jenv;
16683 : (void)jcls;
16684 : (void)jarg1_;
16685 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16686 0 : arg2 = (int)jarg2;
16687 0 : arg3 = (int)jarg3;
16688 0 : arg4 = (int)jarg4;
16689 0 : arg5 = (int)jarg5;
16690 0 : arg6 = (int)jarg6;
16691 0 : arg7 = (int)jarg7;
16692 0 : arg8 = (GDALDataType)jarg8;
16693 : {
16694 0 : if (jarg9 == 0)
16695 : {
16696 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16697 0 : return 0;
16698 : }
16699 :
16700 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
16701 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
16702 0 : if (arg9 == NULL)
16703 : {
16704 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16705 : "Unable to get buffer.");
16706 0 : return 0;
16707 : }
16708 : }
16709 : {
16710 : /* %typemap(in) (int nList, int* pList) */
16711 : /* check if is List */
16712 0 : if (jarg11)
16713 : {
16714 0 : arg11 = jenv->GetArrayLength(jarg11);
16715 0 : if (arg11 == 0)
16716 0 : arg12 = NULL;
16717 : else
16718 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16719 : }
16720 : else
16721 : {
16722 0 : arg11 = 0;
16723 0 : arg12 = NULL;
16724 : }
16725 : }
16726 0 : arg13 = (int)jarg13;
16727 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
16728 0 : jresult = (jint)result;
16729 : {
16730 : /* %typemap(argout) (int nList, int* pList) */
16731 : }
16732 : {
16733 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
16734 : }
16735 : {
16736 : /* %typemap(freearg) (int nList, int* pList) */
16737 0 : if (arg12) {
16738 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16739 : }
16740 : }
16741 0 : return jresult;
16742 : }
16743 :
16744 :
16745 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1WriteRaster_1_1SWIG_123(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jintArray jarg11) {
16746 0 : jint jresult = 0 ;
16747 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
16748 : int arg2 ;
16749 : int arg3 ;
16750 : int arg4 ;
16751 : int arg5 ;
16752 : int arg6 ;
16753 : int arg7 ;
16754 : GDALDataType arg8 ;
16755 0 : double *arg9 = (double *) 0 ;
16756 : size_t arg10 ;
16757 : int arg11 ;
16758 0 : int *arg12 = (int *) 0 ;
16759 : CPLErr result;
16760 :
16761 : (void)jenv;
16762 : (void)jcls;
16763 : (void)jarg1_;
16764 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
16765 0 : arg2 = (int)jarg2;
16766 0 : arg3 = (int)jarg3;
16767 0 : arg4 = (int)jarg4;
16768 0 : arg5 = (int)jarg5;
16769 0 : arg6 = (int)jarg6;
16770 0 : arg7 = (int)jarg7;
16771 0 : arg8 = (GDALDataType)jarg8;
16772 : {
16773 0 : if (jarg9 == 0)
16774 : {
16775 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
16776 0 : return 0;
16777 : }
16778 :
16779 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
16780 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
16781 0 : if (arg9 == NULL)
16782 : {
16783 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
16784 : "Unable to get buffer.");
16785 0 : return 0;
16786 : }
16787 : }
16788 : {
16789 : /* %typemap(in) (int nList, int* pList) */
16790 : /* check if is List */
16791 0 : if (jarg11)
16792 : {
16793 0 : arg11 = jenv->GetArrayLength(jarg11);
16794 0 : if (arg11 == 0)
16795 0 : arg12 = NULL;
16796 : else
16797 0 : arg12 = (int *)jenv->GetIntArrayElements(jarg11, NULL);
16798 : }
16799 : else
16800 : {
16801 0 : arg11 = 0;
16802 0 : arg12 = NULL;
16803 : }
16804 : }
16805 0 : result = (CPLErr)GDALDatasetShadow_WriteRaster__SWIG_20(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
16806 0 : jresult = (jint)result;
16807 : {
16808 : /* %typemap(argout) (int nList, int* pList) */
16809 : }
16810 : {
16811 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
16812 : }
16813 : {
16814 : /* %typemap(freearg) (int nList, int* pList) */
16815 0 : if (arg12) {
16816 0 : jenv->ReleaseIntArrayElements(jarg11, (jint*)arg12, JNI_ABORT);
16817 : }
16818 : }
16819 0 : return jresult;
16820 : }
16821 :
16822 :
16823 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1RasterAttributeTable(JNIEnv *jenv, jclass jcls) {
16824 0 : jlong jresult = 0 ;
16825 0 : GDALRasterAttributeTableShadow *result = 0 ;
16826 :
16827 : (void)jenv;
16828 : (void)jcls;
16829 0 : result = (GDALRasterAttributeTableShadow *)new_GDALRasterAttributeTableShadow();
16830 0 : *(GDALRasterAttributeTableShadow **)&jresult = result;
16831 0 : return jresult;
16832 : }
16833 :
16834 :
16835 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1RasterAttributeTable(JNIEnv *jenv, jclass jcls, jlong jarg1) {
16836 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16837 :
16838 : (void)jenv;
16839 : (void)jcls;
16840 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16841 0 : delete_GDALRasterAttributeTableShadow(arg1);
16842 0 : }
16843 :
16844 :
16845 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1Clone(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
16846 0 : jlong jresult = 0 ;
16847 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16848 0 : GDALRasterAttributeTableShadow *result = 0 ;
16849 :
16850 : (void)jenv;
16851 : (void)jcls;
16852 : (void)jarg1_;
16853 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16854 0 : result = (GDALRasterAttributeTableShadow *)GDALRasterAttributeTableShadow_Clone(arg1);
16855 0 : *(GDALRasterAttributeTableShadow **)&jresult = result;
16856 0 : return jresult;
16857 : }
16858 :
16859 :
16860 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetColumnCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
16861 0 : jint jresult = 0 ;
16862 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16863 : int result;
16864 :
16865 : (void)jenv;
16866 : (void)jcls;
16867 : (void)jarg1_;
16868 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16869 0 : result = (int)GDALRasterAttributeTableShadow_GetColumnCount(arg1);
16870 0 : jresult = (jint)result;
16871 0 : return jresult;
16872 : }
16873 :
16874 :
16875 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetNameOfCol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
16876 0 : jstring jresult = 0 ;
16877 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16878 : int arg2 ;
16879 0 : char *result = 0 ;
16880 :
16881 : (void)jenv;
16882 : (void)jcls;
16883 : (void)jarg1_;
16884 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16885 0 : arg2 = (int)jarg2;
16886 0 : result = (char *)GDALRasterAttributeTableShadow_GetNameOfCol(arg1,arg2);
16887 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
16888 0 : return jresult;
16889 : }
16890 :
16891 :
16892 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetUsageOfCol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
16893 0 : jint jresult = 0 ;
16894 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16895 : int arg2 ;
16896 : GDALRATFieldUsage result;
16897 :
16898 : (void)jenv;
16899 : (void)jcls;
16900 : (void)jarg1_;
16901 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16902 0 : arg2 = (int)jarg2;
16903 0 : result = (GDALRATFieldUsage)GDALRasterAttributeTableShadow_GetUsageOfCol(arg1,arg2);
16904 0 : jresult = (jint)result;
16905 0 : return jresult;
16906 : }
16907 :
16908 :
16909 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetTypeOfCol(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
16910 0 : jint jresult = 0 ;
16911 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16912 : int arg2 ;
16913 : GDALRATFieldType result;
16914 :
16915 : (void)jenv;
16916 : (void)jcls;
16917 : (void)jarg1_;
16918 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16919 0 : arg2 = (int)jarg2;
16920 0 : result = (GDALRATFieldType)GDALRasterAttributeTableShadow_GetTypeOfCol(arg1,arg2);
16921 0 : jresult = (jint)result;
16922 0 : return jresult;
16923 : }
16924 :
16925 :
16926 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetColOfUsage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
16927 0 : jint jresult = 0 ;
16928 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16929 : GDALRATFieldUsage arg2 ;
16930 : int result;
16931 :
16932 : (void)jenv;
16933 : (void)jcls;
16934 : (void)jarg1_;
16935 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16936 0 : arg2 = (GDALRATFieldUsage)jarg2;
16937 0 : result = (int)GDALRasterAttributeTableShadow_GetColOfUsage(arg1,arg2);
16938 0 : jresult = (jint)result;
16939 0 : return jresult;
16940 : }
16941 :
16942 :
16943 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetRowCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
16944 0 : jint jresult = 0 ;
16945 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16946 : int result;
16947 :
16948 : (void)jenv;
16949 : (void)jcls;
16950 : (void)jarg1_;
16951 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16952 0 : result = (int)GDALRasterAttributeTableShadow_GetRowCount(arg1);
16953 0 : jresult = (jint)result;
16954 0 : return jresult;
16955 : }
16956 :
16957 :
16958 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetValueAsString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
16959 0 : jstring jresult = 0 ;
16960 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16961 : int arg2 ;
16962 : int arg3 ;
16963 0 : char *result = 0 ;
16964 :
16965 : (void)jenv;
16966 : (void)jcls;
16967 : (void)jarg1_;
16968 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16969 0 : arg2 = (int)jarg2;
16970 0 : arg3 = (int)jarg3;
16971 0 : result = (char *)GDALRasterAttributeTableShadow_GetValueAsString(arg1,arg2,arg3);
16972 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
16973 0 : return jresult;
16974 : }
16975 :
16976 :
16977 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetValueAsInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
16978 0 : jint jresult = 0 ;
16979 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16980 : int arg2 ;
16981 : int arg3 ;
16982 : int result;
16983 :
16984 : (void)jenv;
16985 : (void)jcls;
16986 : (void)jarg1_;
16987 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
16988 0 : arg2 = (int)jarg2;
16989 0 : arg3 = (int)jarg3;
16990 0 : result = (int)GDALRasterAttributeTableShadow_GetValueAsInt(arg1,arg2,arg3);
16991 0 : jresult = (jint)result;
16992 0 : return jresult;
16993 : }
16994 :
16995 :
16996 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetValueAsDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
16997 0 : jdouble jresult = 0 ;
16998 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
16999 : int arg2 ;
17000 : int arg3 ;
17001 : double result;
17002 :
17003 : (void)jenv;
17004 : (void)jcls;
17005 : (void)jarg1_;
17006 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17007 0 : arg2 = (int)jarg2;
17008 0 : arg3 = (int)jarg3;
17009 0 : result = (double)GDALRasterAttributeTableShadow_GetValueAsDouble(arg1,arg2,arg3);
17010 0 : jresult = (jdouble)result;
17011 0 : return jresult;
17012 : }
17013 :
17014 :
17015 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetValueAsString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jstring jarg4) {
17016 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17017 : int arg2 ;
17018 : int arg3 ;
17019 0 : char *arg4 = (char *) 0 ;
17020 :
17021 : (void)jenv;
17022 : (void)jcls;
17023 : (void)jarg1_;
17024 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17025 0 : arg2 = (int)jarg2;
17026 0 : arg3 = (int)jarg3;
17027 : {
17028 : /* %typemap(in) (tostring argin) */
17029 0 : if (jarg4)
17030 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
17031 : }
17032 0 : GDALRasterAttributeTableShadow_SetValueAsString(arg1,arg2,arg3,(char const *)arg4);
17033 : {
17034 : /* %typemap(freearg) (tostring argin) */
17035 0 : if (jarg4)
17036 0 : jenv->ReleaseStringUTFChars(jarg4, (char*)arg4);
17037 : }
17038 0 : }
17039 :
17040 :
17041 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetValueAsInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4) {
17042 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17043 : int arg2 ;
17044 : int arg3 ;
17045 : int arg4 ;
17046 :
17047 : (void)jenv;
17048 : (void)jcls;
17049 : (void)jarg1_;
17050 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17051 0 : arg2 = (int)jarg2;
17052 0 : arg3 = (int)jarg3;
17053 0 : arg4 = (int)jarg4;
17054 0 : GDALRasterAttributeTableShadow_SetValueAsInt(arg1,arg2,arg3,arg4);
17055 0 : }
17056 :
17057 :
17058 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetValueAsDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jdouble jarg4) {
17059 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17060 : int arg2 ;
17061 : int arg3 ;
17062 : double arg4 ;
17063 :
17064 : (void)jenv;
17065 : (void)jcls;
17066 : (void)jarg1_;
17067 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17068 0 : arg2 = (int)jarg2;
17069 0 : arg3 = (int)jarg3;
17070 0 : arg4 = (double)jarg4;
17071 0 : GDALRasterAttributeTableShadow_SetValueAsDouble(arg1,arg2,arg3,arg4);
17072 0 : }
17073 :
17074 :
17075 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetRowCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
17076 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17077 : int arg2 ;
17078 :
17079 : (void)jenv;
17080 : (void)jcls;
17081 : (void)jarg1_;
17082 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17083 0 : arg2 = (int)jarg2;
17084 0 : GDALRasterAttributeTableShadow_SetRowCount(arg1,arg2);
17085 0 : }
17086 :
17087 :
17088 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1CreateColumn(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
17089 0 : jint jresult = 0 ;
17090 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17091 0 : char *arg2 = (char *) 0 ;
17092 : GDALRATFieldType arg3 ;
17093 : GDALRATFieldUsage arg4 ;
17094 : int result;
17095 :
17096 : (void)jenv;
17097 : (void)jcls;
17098 : (void)jarg1_;
17099 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17100 0 : arg2 = 0;
17101 0 : if (jarg2) {
17102 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17103 0 : if (!arg2) return 0;
17104 : }
17105 0 : arg3 = (GDALRATFieldType)jarg3;
17106 0 : arg4 = (GDALRATFieldUsage)jarg4;
17107 0 : result = (int)GDALRasterAttributeTableShadow_CreateColumn(arg1,(char const *)arg2,arg3,arg4);
17108 0 : jresult = (jint)result;
17109 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17110 0 : return jresult;
17111 : }
17112 :
17113 :
17114 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetLinearBinning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jdoubleArray jarg3) {
17115 0 : jboolean jresult = 0 ;
17116 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17117 0 : double *arg2 = (double *) 0 ;
17118 0 : double *arg3 = (double *) 0 ;
17119 : double temp2 ;
17120 : double temp3 ;
17121 : bool result;
17122 :
17123 : (void)jenv;
17124 : (void)jcls;
17125 : (void)jarg1_;
17126 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17127 : {
17128 0 : if (!jarg2) {
17129 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
17130 0 : return 0;
17131 : }
17132 0 : if (jenv->GetArrayLength(jarg2) == 0) {
17133 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
17134 0 : return 0;
17135 : }
17136 0 : temp2 = (double)0;
17137 0 : arg2 = &temp2;
17138 : }
17139 : {
17140 0 : if (!jarg3) {
17141 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
17142 0 : return 0;
17143 : }
17144 0 : if (jenv->GetArrayLength(jarg3) == 0) {
17145 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
17146 0 : return 0;
17147 : }
17148 0 : temp3 = (double)0;
17149 0 : arg3 = &temp3;
17150 : }
17151 0 : result = (bool)GDALRasterAttributeTableShadow_GetLinearBinning(arg1,arg2,arg3);
17152 0 : jresult = (jboolean)result;
17153 : {
17154 0 : jdouble jvalue = (jdouble)temp2;
17155 0 : jenv->SetDoubleArrayRegion(jarg2, 0, 1, &jvalue);
17156 : }
17157 : {
17158 0 : jdouble jvalue = (jdouble)temp3;
17159 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
17160 : }
17161 :
17162 :
17163 0 : return jresult;
17164 : }
17165 :
17166 :
17167 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetLinearBinning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
17168 0 : jint jresult = 0 ;
17169 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17170 : double arg2 ;
17171 : double arg3 ;
17172 : int result;
17173 :
17174 : (void)jenv;
17175 : (void)jcls;
17176 : (void)jarg1_;
17177 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17178 0 : arg2 = (double)jarg2;
17179 0 : arg3 = (double)jarg3;
17180 0 : result = (int)GDALRasterAttributeTableShadow_SetLinearBinning(arg1,arg2,arg3);
17181 0 : jresult = (jint)result;
17182 0 : return jresult;
17183 : }
17184 :
17185 :
17186 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetRowOfValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
17187 0 : jint jresult = 0 ;
17188 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17189 : double arg2 ;
17190 : int result;
17191 :
17192 : (void)jenv;
17193 : (void)jcls;
17194 : (void)jarg1_;
17195 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17196 0 : arg2 = (double)jarg2;
17197 0 : result = (int)GDALRasterAttributeTableShadow_GetRowOfValue(arg1,arg2);
17198 0 : jresult = (jint)result;
17199 0 : return jresult;
17200 : }
17201 :
17202 :
17203 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1ChangesAreWrittenToFile(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17204 0 : jint jresult = 0 ;
17205 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17206 : int result;
17207 :
17208 : (void)jenv;
17209 : (void)jcls;
17210 : (void)jarg1_;
17211 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17212 0 : result = (int)GDALRasterAttributeTableShadow_ChangesAreWrittenToFile(arg1);
17213 0 : jresult = (jint)result;
17214 0 : return jresult;
17215 : }
17216 :
17217 :
17218 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1DumpReadable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17219 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17220 :
17221 : (void)jenv;
17222 : (void)jcls;
17223 : (void)jarg1_;
17224 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17225 0 : GDALRasterAttributeTableShadow_DumpReadable(arg1);
17226 0 : }
17227 :
17228 :
17229 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1SetTableType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
17230 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17231 : GDALRATTableType arg2 ;
17232 :
17233 : (void)jenv;
17234 : (void)jcls;
17235 : (void)jarg1_;
17236 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17237 0 : arg2 = (GDALRATTableType)jarg2;
17238 0 : GDALRasterAttributeTableShadow_SetTableType(arg1,arg2);
17239 0 : }
17240 :
17241 :
17242 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1GetTableType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17243 0 : jint jresult = 0 ;
17244 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17245 : GDALRATTableType result;
17246 :
17247 : (void)jenv;
17248 : (void)jcls;
17249 : (void)jarg1_;
17250 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17251 0 : result = (GDALRATTableType)GDALRasterAttributeTableShadow_GetTableType(arg1);
17252 0 : jresult = (jint)result;
17253 0 : return jresult;
17254 : }
17255 :
17256 :
17257 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_RasterAttributeTable_1RemoveStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17258 0 : GDALRasterAttributeTableShadow *arg1 = (GDALRasterAttributeTableShadow *) 0 ;
17259 :
17260 : (void)jenv;
17261 : (void)jcls;
17262 : (void)jarg1_;
17263 0 : arg1 = *(GDALRasterAttributeTableShadow **)&jarg1;
17264 0 : GDALRasterAttributeTableShadow_RemoveStatistics(arg1);
17265 0 : }
17266 :
17267 :
17268 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GEDTST_1NONE_1get(JNIEnv *jenv, jclass jcls) {
17269 0 : jint jresult = 0 ;
17270 : GDALExtendedDataTypeSubType result;
17271 :
17272 : (void)jenv;
17273 : (void)jcls;
17274 0 : result = (GDALExtendedDataTypeSubType)GEDTST_NONE;
17275 0 : jresult = (jint)result;
17276 0 : return jresult;
17277 : }
17278 :
17279 :
17280 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GEDTST_1JSON_1get(JNIEnv *jenv, jclass jcls) {
17281 0 : jint jresult = 0 ;
17282 : GDALExtendedDataTypeSubType result;
17283 :
17284 : (void)jenv;
17285 : (void)jcls;
17286 0 : result = (GDALExtendedDataTypeSubType)GEDTST_JSON;
17287 0 : jresult = (jint)result;
17288 0 : return jresult;
17289 : }
17290 :
17291 :
17292 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Group(JNIEnv *jenv, jclass jcls, jlong jarg1) {
17293 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17294 :
17295 : (void)jenv;
17296 : (void)jcls;
17297 0 : arg1 = *(GDALGroupHS **)&jarg1;
17298 0 : delete_GDALGroupHS(arg1);
17299 0 : }
17300 :
17301 :
17302 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17303 0 : jstring jresult = 0 ;
17304 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17305 0 : char *result = 0 ;
17306 :
17307 : (void)jenv;
17308 : (void)jcls;
17309 : (void)jarg1_;
17310 0 : arg1 = *(GDALGroupHS **)&jarg1;
17311 0 : result = (char *)GDALGroupHS_GetName(arg1);
17312 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
17313 0 : return jresult;
17314 : }
17315 :
17316 :
17317 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetFullName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17318 0 : jstring jresult = 0 ;
17319 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17320 0 : char *result = 0 ;
17321 :
17322 : (void)jenv;
17323 : (void)jcls;
17324 : (void)jarg1_;
17325 0 : arg1 = *(GDALGroupHS **)&jarg1;
17326 0 : result = (char *)GDALGroupHS_GetFullName(arg1);
17327 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
17328 0 : return jresult;
17329 : }
17330 :
17331 :
17332 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetMDArrayNames_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
17333 0 : jobject jresult = 0 ;
17334 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17335 0 : char **arg2 = (char **) 0 ;
17336 0 : char **result = 0 ;
17337 :
17338 : (void)jenv;
17339 : (void)jcls;
17340 : (void)jarg1_;
17341 0 : arg1 = *(GDALGroupHS **)&jarg1;
17342 : {
17343 : /* %typemap(in) char **options */
17344 0 : arg2 = NULL;
17345 0 : if(jarg2 != 0) {
17346 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17347 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17348 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17349 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17350 : "()Ljava/util/Enumeration;");
17351 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17352 : "hasMoreElements", "()Z");
17353 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17354 : "nextElement", "()Ljava/lang/Object;");
17355 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17356 0 : hasMoreElements == NULL || getNextElement == NULL) {
17357 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17358 0 : return 0;
17359 : }
17360 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
17361 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17362 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17363 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17364 : {
17365 0 : CSLDestroy(arg2);
17366 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17367 0 : return 0;
17368 : }
17369 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17370 0 : arg2 = CSLAddString(arg2, valptr);
17371 0 : jenv->ReleaseStringUTFChars(value, valptr);
17372 : }
17373 : }
17374 : }
17375 0 : result = (char **)GDALGroupHS_GetMDArrayNames__SWIG_0(arg1,arg2);
17376 : {
17377 : /* %typemap(out) char **CSL */
17378 0 : char **stringarray = result;
17379 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17380 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
17381 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
17382 :
17383 0 : jresult = jenv->NewObject(vector, constructor);
17384 0 : if ( stringarray != NULL ) {
17385 0 : while(*stringarray != NULL) {
17386 : /*printf("working on string %s\n", *stringarray);*/
17387 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
17388 0 : jenv->CallBooleanMethod(jresult, add, value);
17389 0 : jenv->DeleteLocalRef(value);
17390 0 : stringarray++;
17391 : }
17392 : }
17393 0 : CSLDestroy(result);
17394 : }
17395 : {
17396 : /* %typemap(freearg) char **options */
17397 0 : CSLDestroy( arg2 );
17398 : }
17399 0 : return jresult;
17400 : }
17401 :
17402 :
17403 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetMDArrayNames_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17404 0 : jobject jresult = 0 ;
17405 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17406 0 : char **result = 0 ;
17407 :
17408 : (void)jenv;
17409 : (void)jcls;
17410 : (void)jarg1_;
17411 0 : arg1 = *(GDALGroupHS **)&jarg1;
17412 0 : result = (char **)GDALGroupHS_GetMDArrayNames__SWIG_0(arg1);
17413 : {
17414 : /* %typemap(out) char **CSL */
17415 0 : char **stringarray = result;
17416 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17417 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
17418 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
17419 :
17420 0 : jresult = jenv->NewObject(vector, constructor);
17421 0 : if ( stringarray != NULL ) {
17422 0 : while(*stringarray != NULL) {
17423 : /*printf("working on string %s\n", *stringarray);*/
17424 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
17425 0 : jenv->CallBooleanMethod(jresult, add, value);
17426 0 : jenv->DeleteLocalRef(value);
17427 0 : stringarray++;
17428 : }
17429 : }
17430 0 : CSLDestroy(result);
17431 : }
17432 0 : return jresult;
17433 : }
17434 :
17435 :
17436 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenMDArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
17437 0 : jlong jresult = 0 ;
17438 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17439 0 : char *arg2 = (char *) 0 ;
17440 0 : char **arg3 = (char **) 0 ;
17441 0 : GDALMDArrayHS *result = 0 ;
17442 :
17443 : (void)jenv;
17444 : (void)jcls;
17445 : (void)jarg1_;
17446 0 : arg1 = *(GDALGroupHS **)&jarg1;
17447 0 : arg2 = 0;
17448 0 : if (jarg2) {
17449 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17450 0 : if (!arg2) return 0;
17451 : }
17452 : {
17453 : /* %typemap(in) char **options */
17454 0 : arg3 = NULL;
17455 0 : if(jarg3 != 0) {
17456 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17457 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17458 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17459 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17460 : "()Ljava/util/Enumeration;");
17461 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17462 : "hasMoreElements", "()Z");
17463 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17464 : "nextElement", "()Ljava/lang/Object;");
17465 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17466 0 : hasMoreElements == NULL || getNextElement == NULL) {
17467 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17468 0 : return 0;
17469 : }
17470 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
17471 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17472 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17473 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17474 : {
17475 0 : CSLDestroy(arg3);
17476 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17477 0 : return 0;
17478 : }
17479 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17480 0 : arg3 = CSLAddString(arg3, valptr);
17481 0 : jenv->ReleaseStringUTFChars(value, valptr);
17482 : }
17483 : }
17484 : }
17485 : {
17486 0 : if (!arg2) {
17487 : {
17488 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17489 : };
17490 : }
17491 : }
17492 0 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArray__SWIG_0(arg1,(char const *)arg2,arg3);
17493 0 : *(GDALMDArrayHS **)&jresult = result;
17494 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17495 : {
17496 : /* %typemap(freearg) char **options */
17497 0 : CSLDestroy( arg3 );
17498 : }
17499 0 : return jresult;
17500 : }
17501 :
17502 :
17503 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenMDArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
17504 0 : jlong jresult = 0 ;
17505 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17506 0 : char *arg2 = (char *) 0 ;
17507 0 : GDALMDArrayHS *result = 0 ;
17508 :
17509 : (void)jenv;
17510 : (void)jcls;
17511 : (void)jarg1_;
17512 0 : arg1 = *(GDALGroupHS **)&jarg1;
17513 0 : arg2 = 0;
17514 0 : if (jarg2) {
17515 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17516 0 : if (!arg2) return 0;
17517 : }
17518 : {
17519 0 : if (!arg2) {
17520 : {
17521 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17522 : };
17523 : }
17524 : }
17525 0 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArray__SWIG_0(arg1,(char const *)arg2);
17526 0 : *(GDALMDArrayHS **)&jresult = result;
17527 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17528 0 : return jresult;
17529 : }
17530 :
17531 :
17532 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenMDArrayFromFullname_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
17533 0 : jlong jresult = 0 ;
17534 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17535 0 : char *arg2 = (char *) 0 ;
17536 0 : char **arg3 = (char **) 0 ;
17537 0 : GDALMDArrayHS *result = 0 ;
17538 :
17539 : (void)jenv;
17540 : (void)jcls;
17541 : (void)jarg1_;
17542 0 : arg1 = *(GDALGroupHS **)&jarg1;
17543 0 : arg2 = 0;
17544 0 : if (jarg2) {
17545 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17546 0 : if (!arg2) return 0;
17547 : }
17548 : {
17549 : /* %typemap(in) char **options */
17550 0 : arg3 = NULL;
17551 0 : if(jarg3 != 0) {
17552 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17553 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17554 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17555 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17556 : "()Ljava/util/Enumeration;");
17557 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17558 : "hasMoreElements", "()Z");
17559 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17560 : "nextElement", "()Ljava/lang/Object;");
17561 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17562 0 : hasMoreElements == NULL || getNextElement == NULL) {
17563 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17564 0 : return 0;
17565 : }
17566 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
17567 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17568 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17569 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17570 : {
17571 0 : CSLDestroy(arg3);
17572 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17573 0 : return 0;
17574 : }
17575 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17576 0 : arg3 = CSLAddString(arg3, valptr);
17577 0 : jenv->ReleaseStringUTFChars(value, valptr);
17578 : }
17579 : }
17580 : }
17581 : {
17582 0 : if (!arg2) {
17583 : {
17584 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17585 : };
17586 : }
17587 : }
17588 0 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArrayFromFullname__SWIG_0(arg1,(char const *)arg2,arg3);
17589 0 : *(GDALMDArrayHS **)&jresult = result;
17590 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17591 : {
17592 : /* %typemap(freearg) char **options */
17593 0 : CSLDestroy( arg3 );
17594 : }
17595 0 : return jresult;
17596 : }
17597 :
17598 :
17599 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenMDArrayFromFullname_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
17600 0 : jlong jresult = 0 ;
17601 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17602 0 : char *arg2 = (char *) 0 ;
17603 0 : GDALMDArrayHS *result = 0 ;
17604 :
17605 : (void)jenv;
17606 : (void)jcls;
17607 : (void)jarg1_;
17608 0 : arg1 = *(GDALGroupHS **)&jarg1;
17609 0 : arg2 = 0;
17610 0 : if (jarg2) {
17611 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17612 0 : if (!arg2) return 0;
17613 : }
17614 : {
17615 0 : if (!arg2) {
17616 : {
17617 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17618 : };
17619 : }
17620 : }
17621 0 : result = (GDALMDArrayHS *)GDALGroupHS_OpenMDArrayFromFullname__SWIG_0(arg1,(char const *)arg2);
17622 0 : *(GDALMDArrayHS **)&jresult = result;
17623 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17624 0 : return jresult;
17625 : }
17626 :
17627 :
17628 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1ResolveMDArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4) {
17629 0 : jlong jresult = 0 ;
17630 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17631 0 : char *arg2 = (char *) 0 ;
17632 0 : char *arg3 = (char *) 0 ;
17633 0 : char **arg4 = (char **) 0 ;
17634 0 : GDALMDArrayHS *result = 0 ;
17635 :
17636 : (void)jenv;
17637 : (void)jcls;
17638 : (void)jarg1_;
17639 0 : arg1 = *(GDALGroupHS **)&jarg1;
17640 0 : arg2 = 0;
17641 0 : if (jarg2) {
17642 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17643 0 : if (!arg2) return 0;
17644 : }
17645 0 : arg3 = 0;
17646 0 : if (jarg3) {
17647 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
17648 0 : if (!arg3) return 0;
17649 : }
17650 : {
17651 : /* %typemap(in) char **options */
17652 0 : arg4 = NULL;
17653 0 : if(jarg4 != 0) {
17654 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17655 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17656 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17657 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17658 : "()Ljava/util/Enumeration;");
17659 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17660 : "hasMoreElements", "()Z");
17661 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17662 : "nextElement", "()Ljava/lang/Object;");
17663 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17664 0 : hasMoreElements == NULL || getNextElement == NULL) {
17665 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17666 0 : return 0;
17667 : }
17668 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
17669 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17670 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17671 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17672 : {
17673 0 : CSLDestroy(arg4);
17674 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17675 0 : return 0;
17676 : }
17677 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17678 0 : arg4 = CSLAddString(arg4, valptr);
17679 0 : jenv->ReleaseStringUTFChars(value, valptr);
17680 : }
17681 : }
17682 : }
17683 : {
17684 0 : if (!arg2) {
17685 : {
17686 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17687 : };
17688 : }
17689 : }
17690 0 : result = (GDALMDArrayHS *)GDALGroupHS_ResolveMDArray__SWIG_0(arg1,(char const *)arg2,(char const *)arg3,arg4);
17691 0 : *(GDALMDArrayHS **)&jresult = result;
17692 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17693 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
17694 : {
17695 : /* %typemap(freearg) char **options */
17696 0 : CSLDestroy( arg4 );
17697 : }
17698 0 : return jresult;
17699 : }
17700 :
17701 :
17702 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1ResolveMDArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
17703 0 : jlong jresult = 0 ;
17704 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17705 0 : char *arg2 = (char *) 0 ;
17706 0 : char *arg3 = (char *) 0 ;
17707 0 : GDALMDArrayHS *result = 0 ;
17708 :
17709 : (void)jenv;
17710 : (void)jcls;
17711 : (void)jarg1_;
17712 0 : arg1 = *(GDALGroupHS **)&jarg1;
17713 0 : arg2 = 0;
17714 0 : if (jarg2) {
17715 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17716 0 : if (!arg2) return 0;
17717 : }
17718 0 : arg3 = 0;
17719 0 : if (jarg3) {
17720 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
17721 0 : if (!arg3) return 0;
17722 : }
17723 : {
17724 0 : if (!arg2) {
17725 : {
17726 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17727 : };
17728 : }
17729 : }
17730 0 : result = (GDALMDArrayHS *)GDALGroupHS_ResolveMDArray__SWIG_0(arg1,(char const *)arg2,(char const *)arg3);
17731 0 : *(GDALMDArrayHS **)&jresult = result;
17732 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17733 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
17734 0 : return jresult;
17735 : }
17736 :
17737 :
17738 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetGroupNames_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
17739 0 : jobject jresult = 0 ;
17740 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17741 0 : char **arg2 = (char **) 0 ;
17742 0 : char **result = 0 ;
17743 :
17744 : (void)jenv;
17745 : (void)jcls;
17746 : (void)jarg1_;
17747 0 : arg1 = *(GDALGroupHS **)&jarg1;
17748 : {
17749 : /* %typemap(in) char **options */
17750 0 : arg2 = NULL;
17751 0 : if(jarg2 != 0) {
17752 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17753 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17754 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17755 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17756 : "()Ljava/util/Enumeration;");
17757 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17758 : "hasMoreElements", "()Z");
17759 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17760 : "nextElement", "()Ljava/lang/Object;");
17761 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17762 0 : hasMoreElements == NULL || getNextElement == NULL) {
17763 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17764 0 : return 0;
17765 : }
17766 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
17767 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17768 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17769 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17770 : {
17771 0 : CSLDestroy(arg2);
17772 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17773 0 : return 0;
17774 : }
17775 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17776 0 : arg2 = CSLAddString(arg2, valptr);
17777 0 : jenv->ReleaseStringUTFChars(value, valptr);
17778 : }
17779 : }
17780 : }
17781 0 : result = (char **)GDALGroupHS_GetGroupNames__SWIG_0(arg1,arg2);
17782 : {
17783 : /* %typemap(out) char **CSL */
17784 0 : char **stringarray = result;
17785 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17786 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
17787 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
17788 :
17789 0 : jresult = jenv->NewObject(vector, constructor);
17790 0 : if ( stringarray != NULL ) {
17791 0 : while(*stringarray != NULL) {
17792 : /*printf("working on string %s\n", *stringarray);*/
17793 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
17794 0 : jenv->CallBooleanMethod(jresult, add, value);
17795 0 : jenv->DeleteLocalRef(value);
17796 0 : stringarray++;
17797 : }
17798 : }
17799 0 : CSLDestroy(result);
17800 : }
17801 : {
17802 : /* %typemap(freearg) char **options */
17803 0 : CSLDestroy( arg2 );
17804 : }
17805 0 : return jresult;
17806 : }
17807 :
17808 :
17809 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetGroupNames_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
17810 0 : jobject jresult = 0 ;
17811 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17812 0 : char **result = 0 ;
17813 :
17814 : (void)jenv;
17815 : (void)jcls;
17816 : (void)jarg1_;
17817 0 : arg1 = *(GDALGroupHS **)&jarg1;
17818 0 : result = (char **)GDALGroupHS_GetGroupNames__SWIG_0(arg1);
17819 : {
17820 : /* %typemap(out) char **CSL */
17821 0 : char **stringarray = result;
17822 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17823 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
17824 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
17825 :
17826 0 : jresult = jenv->NewObject(vector, constructor);
17827 0 : if ( stringarray != NULL ) {
17828 0 : while(*stringarray != NULL) {
17829 : /*printf("working on string %s\n", *stringarray);*/
17830 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
17831 0 : jenv->CallBooleanMethod(jresult, add, value);
17832 0 : jenv->DeleteLocalRef(value);
17833 0 : stringarray++;
17834 : }
17835 : }
17836 0 : CSLDestroy(result);
17837 : }
17838 0 : return jresult;
17839 : }
17840 :
17841 :
17842 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenGroup_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
17843 0 : jlong jresult = 0 ;
17844 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17845 0 : char *arg2 = (char *) 0 ;
17846 0 : char **arg3 = (char **) 0 ;
17847 0 : GDALGroupHS *result = 0 ;
17848 :
17849 : (void)jenv;
17850 : (void)jcls;
17851 : (void)jarg1_;
17852 0 : arg1 = *(GDALGroupHS **)&jarg1;
17853 0 : arg2 = 0;
17854 0 : if (jarg2) {
17855 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17856 0 : if (!arg2) return 0;
17857 : }
17858 : {
17859 : /* %typemap(in) char **options */
17860 0 : arg3 = NULL;
17861 0 : if(jarg3 != 0) {
17862 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17863 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17864 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17865 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17866 : "()Ljava/util/Enumeration;");
17867 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17868 : "hasMoreElements", "()Z");
17869 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17870 : "nextElement", "()Ljava/lang/Object;");
17871 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17872 0 : hasMoreElements == NULL || getNextElement == NULL) {
17873 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17874 0 : return 0;
17875 : }
17876 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
17877 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17878 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17879 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17880 : {
17881 0 : CSLDestroy(arg3);
17882 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17883 0 : return 0;
17884 : }
17885 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17886 0 : arg3 = CSLAddString(arg3, valptr);
17887 0 : jenv->ReleaseStringUTFChars(value, valptr);
17888 : }
17889 : }
17890 : }
17891 : {
17892 0 : if (!arg2) {
17893 : {
17894 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17895 : };
17896 : }
17897 : }
17898 0 : result = (GDALGroupHS *)GDALGroupHS_OpenGroup__SWIG_0(arg1,(char const *)arg2,arg3);
17899 0 : *(GDALGroupHS **)&jresult = result;
17900 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17901 : {
17902 : /* %typemap(freearg) char **options */
17903 0 : CSLDestroy( arg3 );
17904 : }
17905 0 : return jresult;
17906 : }
17907 :
17908 :
17909 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenGroup_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
17910 0 : jlong jresult = 0 ;
17911 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17912 0 : char *arg2 = (char *) 0 ;
17913 0 : GDALGroupHS *result = 0 ;
17914 :
17915 : (void)jenv;
17916 : (void)jcls;
17917 : (void)jarg1_;
17918 0 : arg1 = *(GDALGroupHS **)&jarg1;
17919 0 : arg2 = 0;
17920 0 : if (jarg2) {
17921 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17922 0 : if (!arg2) return 0;
17923 : }
17924 : {
17925 0 : if (!arg2) {
17926 : {
17927 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17928 : };
17929 : }
17930 : }
17931 0 : result = (GDALGroupHS *)GDALGroupHS_OpenGroup__SWIG_0(arg1,(char const *)arg2);
17932 0 : *(GDALGroupHS **)&jresult = result;
17933 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17934 0 : return jresult;
17935 : }
17936 :
17937 :
17938 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenGroupFromFullname_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
17939 0 : jlong jresult = 0 ;
17940 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
17941 0 : char *arg2 = (char *) 0 ;
17942 0 : char **arg3 = (char **) 0 ;
17943 0 : GDALGroupHS *result = 0 ;
17944 :
17945 : (void)jenv;
17946 : (void)jcls;
17947 : (void)jarg1_;
17948 0 : arg1 = *(GDALGroupHS **)&jarg1;
17949 0 : arg2 = 0;
17950 0 : if (jarg2) {
17951 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
17952 0 : if (!arg2) return 0;
17953 : }
17954 : {
17955 : /* %typemap(in) char **options */
17956 0 : arg3 = NULL;
17957 0 : if(jarg3 != 0) {
17958 0 : const jclass vector = jenv->FindClass("java/util/Vector");
17959 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
17960 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
17961 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
17962 : "()Ljava/util/Enumeration;");
17963 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
17964 : "hasMoreElements", "()Z");
17965 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
17966 : "nextElement", "()Ljava/lang/Object;");
17967 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
17968 0 : hasMoreElements == NULL || getNextElement == NULL) {
17969 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
17970 0 : return 0;
17971 : }
17972 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
17973 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
17974 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
17975 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
17976 : {
17977 0 : CSLDestroy(arg3);
17978 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
17979 0 : return 0;
17980 : }
17981 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
17982 0 : arg3 = CSLAddString(arg3, valptr);
17983 0 : jenv->ReleaseStringUTFChars(value, valptr);
17984 : }
17985 : }
17986 : }
17987 : {
17988 0 : if (!arg2) {
17989 : {
17990 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
17991 : };
17992 : }
17993 : }
17994 0 : result = (GDALGroupHS *)GDALGroupHS_OpenGroupFromFullname__SWIG_0(arg1,(char const *)arg2,arg3);
17995 0 : *(GDALGroupHS **)&jresult = result;
17996 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
17997 : {
17998 : /* %typemap(freearg) char **options */
17999 0 : CSLDestroy( arg3 );
18000 : }
18001 0 : return jresult;
18002 : }
18003 :
18004 :
18005 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenGroupFromFullname_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18006 0 : jlong jresult = 0 ;
18007 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18008 0 : char *arg2 = (char *) 0 ;
18009 0 : GDALGroupHS *result = 0 ;
18010 :
18011 : (void)jenv;
18012 : (void)jcls;
18013 : (void)jarg1_;
18014 0 : arg1 = *(GDALGroupHS **)&jarg1;
18015 0 : arg2 = 0;
18016 0 : if (jarg2) {
18017 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18018 0 : if (!arg2) return 0;
18019 : }
18020 : {
18021 0 : if (!arg2) {
18022 : {
18023 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18024 : };
18025 : }
18026 : }
18027 0 : result = (GDALGroupHS *)GDALGroupHS_OpenGroupFromFullname__SWIG_0(arg1,(char const *)arg2);
18028 0 : *(GDALGroupHS **)&jresult = result;
18029 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18030 0 : return jresult;
18031 : }
18032 :
18033 :
18034 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetVectorLayerNames_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
18035 0 : jobject jresult = 0 ;
18036 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18037 0 : char **arg2 = (char **) 0 ;
18038 0 : char **result = 0 ;
18039 :
18040 : (void)jenv;
18041 : (void)jcls;
18042 : (void)jarg1_;
18043 0 : arg1 = *(GDALGroupHS **)&jarg1;
18044 : {
18045 : /* %typemap(in) char **options */
18046 0 : arg2 = NULL;
18047 0 : if(jarg2 != 0) {
18048 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18049 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18050 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18051 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18052 : "()Ljava/util/Enumeration;");
18053 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18054 : "hasMoreElements", "()Z");
18055 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18056 : "nextElement", "()Ljava/lang/Object;");
18057 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18058 0 : hasMoreElements == NULL || getNextElement == NULL) {
18059 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18060 0 : return 0;
18061 : }
18062 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
18063 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18064 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18065 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18066 : {
18067 0 : CSLDestroy(arg2);
18068 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18069 0 : return 0;
18070 : }
18071 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18072 0 : arg2 = CSLAddString(arg2, valptr);
18073 0 : jenv->ReleaseStringUTFChars(value, valptr);
18074 : }
18075 : }
18076 : }
18077 0 : result = (char **)GDALGroupHS_GetVectorLayerNames__SWIG_0(arg1,arg2);
18078 : {
18079 : /* %typemap(out) char **CSL */
18080 0 : char **stringarray = result;
18081 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18082 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
18083 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
18084 :
18085 0 : jresult = jenv->NewObject(vector, constructor);
18086 0 : if ( stringarray != NULL ) {
18087 0 : while(*stringarray != NULL) {
18088 : /*printf("working on string %s\n", *stringarray);*/
18089 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
18090 0 : jenv->CallBooleanMethod(jresult, add, value);
18091 0 : jenv->DeleteLocalRef(value);
18092 0 : stringarray++;
18093 : }
18094 : }
18095 0 : CSLDestroy(result);
18096 : }
18097 : {
18098 : /* %typemap(freearg) char **options */
18099 0 : CSLDestroy( arg2 );
18100 : }
18101 0 : return jresult;
18102 : }
18103 :
18104 :
18105 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetVectorLayerNames_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
18106 0 : jobject jresult = 0 ;
18107 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18108 0 : char **result = 0 ;
18109 :
18110 : (void)jenv;
18111 : (void)jcls;
18112 : (void)jarg1_;
18113 0 : arg1 = *(GDALGroupHS **)&jarg1;
18114 0 : result = (char **)GDALGroupHS_GetVectorLayerNames__SWIG_0(arg1);
18115 : {
18116 : /* %typemap(out) char **CSL */
18117 0 : char **stringarray = result;
18118 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18119 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
18120 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
18121 :
18122 0 : jresult = jenv->NewObject(vector, constructor);
18123 0 : if ( stringarray != NULL ) {
18124 0 : while(*stringarray != NULL) {
18125 : /*printf("working on string %s\n", *stringarray);*/
18126 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
18127 0 : jenv->CallBooleanMethod(jresult, add, value);
18128 0 : jenv->DeleteLocalRef(value);
18129 0 : stringarray++;
18130 : }
18131 : }
18132 0 : CSLDestroy(result);
18133 : }
18134 0 : return jresult;
18135 : }
18136 :
18137 :
18138 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenVectorLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
18139 0 : jlong jresult = 0 ;
18140 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18141 0 : char *arg2 = (char *) 0 ;
18142 0 : char **arg3 = (char **) 0 ;
18143 0 : OGRLayerShadow *result = 0 ;
18144 :
18145 : (void)jenv;
18146 : (void)jcls;
18147 : (void)jarg1_;
18148 0 : arg1 = *(GDALGroupHS **)&jarg1;
18149 0 : arg2 = 0;
18150 0 : if (jarg2) {
18151 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18152 0 : if (!arg2) return 0;
18153 : }
18154 : {
18155 : /* %typemap(in) char **options */
18156 0 : arg3 = NULL;
18157 0 : if(jarg3 != 0) {
18158 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18159 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18160 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18161 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18162 : "()Ljava/util/Enumeration;");
18163 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18164 : "hasMoreElements", "()Z");
18165 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18166 : "nextElement", "()Ljava/lang/Object;");
18167 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18168 0 : hasMoreElements == NULL || getNextElement == NULL) {
18169 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18170 0 : return 0;
18171 : }
18172 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
18173 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18174 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18175 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18176 : {
18177 0 : CSLDestroy(arg3);
18178 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18179 0 : return 0;
18180 : }
18181 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18182 0 : arg3 = CSLAddString(arg3, valptr);
18183 0 : jenv->ReleaseStringUTFChars(value, valptr);
18184 : }
18185 : }
18186 : }
18187 : {
18188 0 : if (!arg2) {
18189 : {
18190 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18191 : };
18192 : }
18193 : }
18194 0 : result = (OGRLayerShadow *)GDALGroupHS_OpenVectorLayer__SWIG_0(arg1,(char const *)arg2,arg3);
18195 0 : *(OGRLayerShadow **)&jresult = result;
18196 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18197 : {
18198 : /* %typemap(freearg) char **options */
18199 0 : CSLDestroy( arg3 );
18200 : }
18201 0 : return jresult;
18202 : }
18203 :
18204 :
18205 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1OpenVectorLayer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18206 0 : jlong jresult = 0 ;
18207 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18208 0 : char *arg2 = (char *) 0 ;
18209 0 : OGRLayerShadow *result = 0 ;
18210 :
18211 : (void)jenv;
18212 : (void)jcls;
18213 : (void)jarg1_;
18214 0 : arg1 = *(GDALGroupHS **)&jarg1;
18215 0 : arg2 = 0;
18216 0 : if (jarg2) {
18217 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18218 0 : if (!arg2) return 0;
18219 : }
18220 : {
18221 0 : if (!arg2) {
18222 : {
18223 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18224 : };
18225 : }
18226 : }
18227 0 : result = (OGRLayerShadow *)GDALGroupHS_OpenVectorLayer__SWIG_0(arg1,(char const *)arg2);
18228 0 : *(OGRLayerShadow **)&jresult = result;
18229 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18230 0 : return jresult;
18231 : }
18232 :
18233 :
18234 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetAttribute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18235 0 : jlong jresult = 0 ;
18236 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18237 0 : char *arg2 = (char *) 0 ;
18238 0 : GDALAttributeHS *result = 0 ;
18239 :
18240 : (void)jenv;
18241 : (void)jcls;
18242 : (void)jarg1_;
18243 0 : arg1 = *(GDALGroupHS **)&jarg1;
18244 0 : arg2 = 0;
18245 0 : if (jarg2) {
18246 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18247 0 : if (!arg2) return 0;
18248 : }
18249 : {
18250 0 : if (!arg2) {
18251 : {
18252 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18253 : };
18254 : }
18255 : }
18256 0 : result = (GDALAttributeHS *)GDALGroupHS_GetAttribute(arg1,(char const *)arg2);
18257 0 : *(GDALAttributeHS **)&jresult = result;
18258 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18259 0 : return jresult;
18260 : }
18261 :
18262 :
18263 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Group_1GetStructuralInfo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
18264 0 : jobject jresult = 0 ;
18265 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18266 0 : char **result = 0 ;
18267 :
18268 : (void)jenv;
18269 : (void)jcls;
18270 : (void)jarg1_;
18271 0 : arg1 = *(GDALGroupHS **)&jarg1;
18272 0 : result = (char **)GDALGroupHS_GetStructuralInfo(arg1);
18273 : {
18274 : /* %typemap(out) char **dict */
18275 0 : jresult = GetCSLStringAsHashTable(jenv, result, false);
18276 : }
18277 0 : return jresult;
18278 : }
18279 :
18280 :
18281 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateGroup_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
18282 0 : jlong jresult = 0 ;
18283 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18284 0 : char *arg2 = (char *) 0 ;
18285 0 : char **arg3 = (char **) 0 ;
18286 0 : GDALGroupHS *result = 0 ;
18287 :
18288 : (void)jenv;
18289 : (void)jcls;
18290 : (void)jarg1_;
18291 0 : arg1 = *(GDALGroupHS **)&jarg1;
18292 0 : arg2 = 0;
18293 0 : if (jarg2) {
18294 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18295 0 : if (!arg2) return 0;
18296 : }
18297 : {
18298 : /* %typemap(in) char **options */
18299 0 : arg3 = NULL;
18300 0 : if(jarg3 != 0) {
18301 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18302 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18303 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18304 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18305 : "()Ljava/util/Enumeration;");
18306 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18307 : "hasMoreElements", "()Z");
18308 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18309 : "nextElement", "()Ljava/lang/Object;");
18310 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18311 0 : hasMoreElements == NULL || getNextElement == NULL) {
18312 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18313 0 : return 0;
18314 : }
18315 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
18316 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18317 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18318 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18319 : {
18320 0 : CSLDestroy(arg3);
18321 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18322 0 : return 0;
18323 : }
18324 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18325 0 : arg3 = CSLAddString(arg3, valptr);
18326 0 : jenv->ReleaseStringUTFChars(value, valptr);
18327 : }
18328 : }
18329 : }
18330 : {
18331 0 : if (!arg2) {
18332 : {
18333 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18334 : };
18335 : }
18336 : }
18337 0 : result = (GDALGroupHS *)GDALGroupHS_CreateGroup__SWIG_0(arg1,(char const *)arg2,arg3);
18338 0 : *(GDALGroupHS **)&jresult = result;
18339 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18340 : {
18341 : /* %typemap(freearg) char **options */
18342 0 : CSLDestroy( arg3 );
18343 : }
18344 0 : return jresult;
18345 : }
18346 :
18347 :
18348 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateGroup_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18349 0 : jlong jresult = 0 ;
18350 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18351 0 : char *arg2 = (char *) 0 ;
18352 0 : GDALGroupHS *result = 0 ;
18353 :
18354 : (void)jenv;
18355 : (void)jcls;
18356 : (void)jarg1_;
18357 0 : arg1 = *(GDALGroupHS **)&jarg1;
18358 0 : arg2 = 0;
18359 0 : if (jarg2) {
18360 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18361 0 : if (!arg2) return 0;
18362 : }
18363 : {
18364 0 : if (!arg2) {
18365 : {
18366 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18367 : };
18368 : }
18369 : }
18370 0 : result = (GDALGroupHS *)GDALGroupHS_CreateGroup__SWIG_0(arg1,(char const *)arg2);
18371 0 : *(GDALGroupHS **)&jresult = result;
18372 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18373 0 : return jresult;
18374 : }
18375 :
18376 :
18377 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteGroup_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
18378 0 : jint jresult = 0 ;
18379 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18380 0 : char *arg2 = (char *) 0 ;
18381 0 : char **arg3 = (char **) 0 ;
18382 : CPLErr result;
18383 :
18384 : (void)jenv;
18385 : (void)jcls;
18386 : (void)jarg1_;
18387 0 : arg1 = *(GDALGroupHS **)&jarg1;
18388 0 : arg2 = 0;
18389 0 : if (jarg2) {
18390 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18391 0 : if (!arg2) return 0;
18392 : }
18393 : {
18394 : /* %typemap(in) char **options */
18395 0 : arg3 = NULL;
18396 0 : if(jarg3 != 0) {
18397 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18398 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18399 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18400 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18401 : "()Ljava/util/Enumeration;");
18402 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18403 : "hasMoreElements", "()Z");
18404 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18405 : "nextElement", "()Ljava/lang/Object;");
18406 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18407 0 : hasMoreElements == NULL || getNextElement == NULL) {
18408 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18409 0 : return 0;
18410 : }
18411 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
18412 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18413 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18414 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18415 : {
18416 0 : CSLDestroy(arg3);
18417 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18418 0 : return 0;
18419 : }
18420 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18421 0 : arg3 = CSLAddString(arg3, valptr);
18422 0 : jenv->ReleaseStringUTFChars(value, valptr);
18423 : }
18424 : }
18425 : }
18426 : {
18427 0 : if (!arg2) {
18428 : {
18429 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18430 : };
18431 : }
18432 : }
18433 0 : result = (CPLErr)GDALGroupHS_DeleteGroup__SWIG_0(arg1,(char const *)arg2,arg3);
18434 0 : jresult = (jint)result;
18435 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18436 : {
18437 : /* %typemap(freearg) char **options */
18438 0 : CSLDestroy( arg3 );
18439 : }
18440 0 : return jresult;
18441 : }
18442 :
18443 :
18444 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteGroup_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18445 0 : jint jresult = 0 ;
18446 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18447 0 : char *arg2 = (char *) 0 ;
18448 : CPLErr result;
18449 :
18450 : (void)jenv;
18451 : (void)jcls;
18452 : (void)jarg1_;
18453 0 : arg1 = *(GDALGroupHS **)&jarg1;
18454 0 : arg2 = 0;
18455 0 : if (jarg2) {
18456 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18457 0 : if (!arg2) return 0;
18458 : }
18459 : {
18460 0 : if (!arg2) {
18461 : {
18462 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18463 : };
18464 : }
18465 : }
18466 0 : result = (CPLErr)GDALGroupHS_DeleteGroup__SWIG_0(arg1,(char const *)arg2);
18467 0 : jresult = (jint)result;
18468 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18469 0 : return jresult;
18470 : }
18471 :
18472 :
18473 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateDimension_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jlong jarg5, jobject jarg6) {
18474 0 : jlong jresult = 0 ;
18475 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18476 0 : char *arg2 = (char *) 0 ;
18477 0 : char *arg3 = (char *) 0 ;
18478 0 : char *arg4 = (char *) 0 ;
18479 : GUIntBig arg5 ;
18480 0 : char **arg6 = (char **) 0 ;
18481 0 : GDALDimensionHS *result = 0 ;
18482 :
18483 : (void)jenv;
18484 : (void)jcls;
18485 : (void)jarg1_;
18486 0 : arg1 = *(GDALGroupHS **)&jarg1;
18487 0 : arg2 = 0;
18488 0 : if (jarg2) {
18489 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18490 0 : if (!arg2) return 0;
18491 : }
18492 0 : arg3 = 0;
18493 0 : if (jarg3) {
18494 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
18495 0 : if (!arg3) return 0;
18496 : }
18497 0 : arg4 = 0;
18498 0 : if (jarg4) {
18499 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
18500 0 : if (!arg4) return 0;
18501 : }
18502 : {
18503 : /* %typemap(in) (GUIntBig) */
18504 0 : arg5 = (GUIntBig) jarg5;
18505 : }
18506 : {
18507 : /* %typemap(in) char **options */
18508 0 : arg6 = NULL;
18509 0 : if(jarg6 != 0) {
18510 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18511 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18512 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18513 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18514 : "()Ljava/util/Enumeration;");
18515 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18516 : "hasMoreElements", "()Z");
18517 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18518 : "nextElement", "()Ljava/lang/Object;");
18519 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18520 0 : hasMoreElements == NULL || getNextElement == NULL) {
18521 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18522 0 : return 0;
18523 : }
18524 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
18525 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18526 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18527 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18528 : {
18529 0 : CSLDestroy(arg6);
18530 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18531 0 : return 0;
18532 : }
18533 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18534 0 : arg6 = CSLAddString(arg6, valptr);
18535 0 : jenv->ReleaseStringUTFChars(value, valptr);
18536 : }
18537 : }
18538 : }
18539 : {
18540 0 : if (!arg2) {
18541 : {
18542 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18543 : };
18544 : }
18545 : }
18546 0 : result = (GDALDimensionHS *)GDALGroupHS_CreateDimension__SWIG_0(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
18547 0 : *(GDALDimensionHS **)&jresult = result;
18548 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18549 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
18550 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
18551 : {
18552 : /* %typemap(freearg) char **options */
18553 0 : CSLDestroy( arg6 );
18554 : }
18555 0 : return jresult;
18556 : }
18557 :
18558 :
18559 10 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateDimension_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jlong jarg5) {
18560 10 : jlong jresult = 0 ;
18561 10 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18562 10 : char *arg2 = (char *) 0 ;
18563 10 : char *arg3 = (char *) 0 ;
18564 10 : char *arg4 = (char *) 0 ;
18565 : GUIntBig arg5 ;
18566 10 : GDALDimensionHS *result = 0 ;
18567 :
18568 : (void)jenv;
18569 : (void)jcls;
18570 : (void)jarg1_;
18571 10 : arg1 = *(GDALGroupHS **)&jarg1;
18572 10 : arg2 = 0;
18573 10 : if (jarg2) {
18574 10 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18575 10 : if (!arg2) return 0;
18576 : }
18577 10 : arg3 = 0;
18578 10 : if (jarg3) {
18579 10 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
18580 10 : if (!arg3) return 0;
18581 : }
18582 10 : arg4 = 0;
18583 10 : if (jarg4) {
18584 10 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
18585 10 : if (!arg4) return 0;
18586 : }
18587 : {
18588 : /* %typemap(in) (GUIntBig) */
18589 10 : arg5 = (GUIntBig) jarg5;
18590 : }
18591 : {
18592 10 : if (!arg2) {
18593 : {
18594 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18595 : };
18596 : }
18597 : }
18598 10 : result = (GDALDimensionHS *)GDALGroupHS_CreateDimension__SWIG_0(arg1,(char const *)arg2,(char const *)arg3,(char const *)arg4,arg5);
18599 10 : *(GDALDimensionHS **)&jresult = result;
18600 10 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18601 10 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
18602 10 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
18603 10 : return jresult;
18604 : }
18605 :
18606 :
18607 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateMDArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobjectArray jarg3, jlong jarg5, jobject jarg5_, jobject jarg6) {
18608 0 : jlong jresult = 0 ;
18609 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18610 0 : char *arg2 = (char *) 0 ;
18611 : int arg3 ;
18612 0 : GDALDimensionHS **arg4 = (GDALDimensionHS **) 0 ;
18613 0 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
18614 0 : char **arg6 = (char **) 0 ;
18615 0 : GDALMDArrayHS *result = 0 ;
18616 :
18617 : (void)jenv;
18618 : (void)jcls;
18619 : (void)jarg1_;
18620 : (void)jarg5_;
18621 0 : arg1 = *(GDALGroupHS **)&jarg1;
18622 0 : arg2 = 0;
18623 0 : if (jarg2) {
18624 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18625 0 : if (!arg2) return 0;
18626 : }
18627 : {
18628 : /* %typemap(in, numinputs=1) (int object_list_count, GDALDimensionHS **poObjects) */
18629 0 : if (jarg3)
18630 : {
18631 0 : const jclass dimClass = jenv->FindClass("org/gdal/gdal/Dimension");
18632 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(dimClass, "getCPtr", "(Lorg/gdal/gdal/Dimension;)J");
18633 :
18634 0 : arg3 = jenv->GetArrayLength(jarg3);
18635 0 : if (arg3 == 0) {
18636 0 : arg4 = NULL;
18637 : }
18638 : else
18639 : {
18640 0 : arg4 = (GDALDimensionH*) malloc(sizeof(GDALDimensionH) * arg3);
18641 :
18642 : int i;
18643 0 : for (i=0; i<arg3; i++) {
18644 0 : jobject obj = jenv->GetObjectArrayElement(jarg3, i);
18645 0 : if (obj == NULL)
18646 : {
18647 0 : free(arg4);
18648 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
18649 0 : return 0;
18650 : }
18651 0 : arg4[i] = (GDALDimensionH) jenv->CallStaticLongMethod(dimClass, getCPtr, obj);
18652 : }
18653 : }
18654 : }
18655 : else
18656 : {
18657 0 : arg3 = 0;
18658 0 : arg4 = (GDALDimensionH*) NULL;
18659 : }
18660 : }
18661 0 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
18662 : {
18663 : /* %typemap(in) char **options */
18664 0 : arg6 = NULL;
18665 0 : if(jarg6 != 0) {
18666 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18667 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18668 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18669 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18670 : "()Ljava/util/Enumeration;");
18671 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18672 : "hasMoreElements", "()Z");
18673 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18674 : "nextElement", "()Ljava/lang/Object;");
18675 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18676 0 : hasMoreElements == NULL || getNextElement == NULL) {
18677 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18678 0 : return 0;
18679 : }
18680 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
18681 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18682 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18683 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18684 : {
18685 0 : CSLDestroy(arg6);
18686 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18687 0 : return 0;
18688 : }
18689 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18690 0 : arg6 = CSLAddString(arg6, valptr);
18691 0 : jenv->ReleaseStringUTFChars(value, valptr);
18692 : }
18693 : }
18694 : }
18695 : {
18696 0 : if (!arg2) {
18697 : {
18698 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18699 : };
18700 : }
18701 : }
18702 : {
18703 0 : if (!arg5) {
18704 : {
18705 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18706 : };
18707 : }
18708 : }
18709 0 : result = (GDALMDArrayHS *)GDALGroupHS_CreateMDArray__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
18710 0 : *(GDALMDArrayHS **)&jresult = result;
18711 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18712 : {
18713 : /* %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjects) */
18714 0 : if (arg4) {
18715 0 : free((void*) arg4);
18716 : }
18717 : }
18718 : {
18719 : /* %typemap(freearg) char **options */
18720 0 : CSLDestroy( arg6 );
18721 : }
18722 0 : return jresult;
18723 : }
18724 :
18725 :
18726 4 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateMDArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobjectArray jarg3, jlong jarg5, jobject jarg5_) {
18727 4 : jlong jresult = 0 ;
18728 4 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18729 4 : char *arg2 = (char *) 0 ;
18730 : int arg3 ;
18731 4 : GDALDimensionHS **arg4 = (GDALDimensionHS **) 0 ;
18732 4 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
18733 4 : GDALMDArrayHS *result = 0 ;
18734 :
18735 : (void)jenv;
18736 : (void)jcls;
18737 : (void)jarg1_;
18738 : (void)jarg5_;
18739 4 : arg1 = *(GDALGroupHS **)&jarg1;
18740 4 : arg2 = 0;
18741 4 : if (jarg2) {
18742 4 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18743 4 : if (!arg2) return 0;
18744 : }
18745 : {
18746 : /* %typemap(in, numinputs=1) (int object_list_count, GDALDimensionHS **poObjects) */
18747 4 : if (jarg3)
18748 : {
18749 4 : const jclass dimClass = jenv->FindClass("org/gdal/gdal/Dimension");
18750 4 : const jmethodID getCPtr = jenv->GetStaticMethodID(dimClass, "getCPtr", "(Lorg/gdal/gdal/Dimension;)J");
18751 :
18752 4 : arg3 = jenv->GetArrayLength(jarg3);
18753 4 : if (arg3 == 0) {
18754 0 : arg4 = NULL;
18755 : }
18756 : else
18757 : {
18758 4 : arg4 = (GDALDimensionH*) malloc(sizeof(GDALDimensionH) * arg3);
18759 :
18760 : int i;
18761 14 : for (i=0; i<arg3; i++) {
18762 10 : jobject obj = jenv->GetObjectArrayElement(jarg3, i);
18763 10 : if (obj == NULL)
18764 : {
18765 0 : free(arg4);
18766 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
18767 0 : return 0;
18768 : }
18769 10 : arg4[i] = (GDALDimensionH) jenv->CallStaticLongMethod(dimClass, getCPtr, obj);
18770 : }
18771 : }
18772 : }
18773 : else
18774 : {
18775 0 : arg3 = 0;
18776 0 : arg4 = (GDALDimensionH*) NULL;
18777 : }
18778 : }
18779 4 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
18780 : {
18781 4 : if (!arg2) {
18782 : {
18783 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18784 : };
18785 : }
18786 : }
18787 : {
18788 4 : if (!arg5) {
18789 : {
18790 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18791 : };
18792 : }
18793 : }
18794 4 : result = (GDALMDArrayHS *)GDALGroupHS_CreateMDArray__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
18795 4 : *(GDALMDArrayHS **)&jresult = result;
18796 4 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18797 : {
18798 : /* %typemap(freearg) (int object_list_count, GDALDimensionHS **poObjects) */
18799 4 : if (arg4) {
18800 4 : free((void*) arg4);
18801 : }
18802 : }
18803 4 : return jresult;
18804 : }
18805 :
18806 :
18807 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteMDArray_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
18808 0 : jint jresult = 0 ;
18809 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18810 0 : char *arg2 = (char *) 0 ;
18811 0 : char **arg3 = (char **) 0 ;
18812 : CPLErr result;
18813 :
18814 : (void)jenv;
18815 : (void)jcls;
18816 : (void)jarg1_;
18817 0 : arg1 = *(GDALGroupHS **)&jarg1;
18818 0 : arg2 = 0;
18819 0 : if (jarg2) {
18820 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18821 0 : if (!arg2) return 0;
18822 : }
18823 : {
18824 : /* %typemap(in) char **options */
18825 0 : arg3 = NULL;
18826 0 : if(jarg3 != 0) {
18827 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18828 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18829 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18830 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18831 : "()Ljava/util/Enumeration;");
18832 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18833 : "hasMoreElements", "()Z");
18834 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18835 : "nextElement", "()Ljava/lang/Object;");
18836 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18837 0 : hasMoreElements == NULL || getNextElement == NULL) {
18838 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18839 0 : return 0;
18840 : }
18841 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
18842 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18843 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18844 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18845 : {
18846 0 : CSLDestroy(arg3);
18847 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18848 0 : return 0;
18849 : }
18850 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18851 0 : arg3 = CSLAddString(arg3, valptr);
18852 0 : jenv->ReleaseStringUTFChars(value, valptr);
18853 : }
18854 : }
18855 : }
18856 : {
18857 0 : if (!arg2) {
18858 : {
18859 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18860 : };
18861 : }
18862 : }
18863 0 : result = (CPLErr)GDALGroupHS_DeleteMDArray__SWIG_0(arg1,(char const *)arg2,arg3);
18864 0 : jresult = (jint)result;
18865 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18866 : {
18867 : /* %typemap(freearg) char **options */
18868 0 : CSLDestroy( arg3 );
18869 : }
18870 0 : return jresult;
18871 : }
18872 :
18873 :
18874 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteMDArray_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
18875 0 : jint jresult = 0 ;
18876 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18877 0 : char *arg2 = (char *) 0 ;
18878 : CPLErr result;
18879 :
18880 : (void)jenv;
18881 : (void)jcls;
18882 : (void)jarg1_;
18883 0 : arg1 = *(GDALGroupHS **)&jarg1;
18884 0 : arg2 = 0;
18885 0 : if (jarg2) {
18886 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18887 0 : if (!arg2) return 0;
18888 : }
18889 : {
18890 0 : if (!arg2) {
18891 : {
18892 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18893 : };
18894 : }
18895 : }
18896 0 : result = (CPLErr)GDALGroupHS_DeleteMDArray__SWIG_0(arg1,(char const *)arg2);
18897 0 : jresult = (jint)result;
18898 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18899 0 : return jresult;
18900 : }
18901 :
18902 :
18903 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateAttribute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlongArray jarg3, jlong jarg5, jobject jarg5_, jobject jarg6) {
18904 0 : jlong jresult = 0 ;
18905 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
18906 0 : char *arg2 = (char *) 0 ;
18907 : int arg3 ;
18908 0 : GUIntBig *arg4 = (GUIntBig *) 0 ;
18909 0 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
18910 0 : char **arg6 = (char **) 0 ;
18911 0 : GDALAttributeHS *result = 0 ;
18912 :
18913 : (void)jenv;
18914 : (void)jcls;
18915 : (void)jarg1_;
18916 : (void)jarg5_;
18917 0 : arg1 = *(GDALGroupHS **)&jarg1;
18918 0 : arg2 = 0;
18919 0 : if (jarg2) {
18920 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
18921 0 : if (!arg2) return 0;
18922 : }
18923 : {
18924 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
18925 0 : if (jarg3)
18926 : {
18927 0 : arg3 = jenv->GetArrayLength(jarg3);
18928 0 : if (arg3 == 0)
18929 0 : arg4 = (GUIntBig *) NULL;
18930 : else
18931 0 : arg4 = (GUIntBig *) jenv->GetLongArrayElements(jarg3, NULL);
18932 : }
18933 : else {
18934 0 : arg3 = 0;
18935 0 : arg4 = (GUIntBig *) NULL;
18936 : }
18937 : }
18938 0 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
18939 : {
18940 : /* %typemap(in) char **options */
18941 0 : arg6 = NULL;
18942 0 : if(jarg6 != 0) {
18943 0 : const jclass vector = jenv->FindClass("java/util/Vector");
18944 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
18945 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
18946 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
18947 : "()Ljava/util/Enumeration;");
18948 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
18949 : "hasMoreElements", "()Z");
18950 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
18951 : "nextElement", "()Ljava/lang/Object;");
18952 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
18953 0 : hasMoreElements == NULL || getNextElement == NULL) {
18954 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
18955 0 : return 0;
18956 : }
18957 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
18958 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
18959 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
18960 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
18961 : {
18962 0 : CSLDestroy(arg6);
18963 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
18964 0 : return 0;
18965 : }
18966 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
18967 0 : arg6 = CSLAddString(arg6, valptr);
18968 0 : jenv->ReleaseStringUTFChars(value, valptr);
18969 : }
18970 : }
18971 : }
18972 : {
18973 0 : if (!arg2) {
18974 : {
18975 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18976 : };
18977 : }
18978 : }
18979 : {
18980 0 : if (!arg5) {
18981 : {
18982 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
18983 : };
18984 : }
18985 : }
18986 0 : result = (GDALAttributeHS *)GDALGroupHS_CreateAttribute__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
18987 0 : *(GDALAttributeHS **)&jresult = result;
18988 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
18989 : {
18990 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
18991 0 : if (arg4) {
18992 0 : jenv->ReleaseLongArrayElements(jarg3, (jlong*)arg4, JNI_ABORT);
18993 : }
18994 : }
18995 : {
18996 : /* %typemap(freearg) char **options */
18997 0 : CSLDestroy( arg6 );
18998 : }
18999 0 : return jresult;
19000 : }
19001 :
19002 :
19003 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1CreateAttribute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlongArray jarg3, jlong jarg5, jobject jarg5_) {
19004 0 : jlong jresult = 0 ;
19005 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19006 0 : char *arg2 = (char *) 0 ;
19007 : int arg3 ;
19008 0 : GUIntBig *arg4 = (GUIntBig *) 0 ;
19009 0 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
19010 0 : GDALAttributeHS *result = 0 ;
19011 :
19012 : (void)jenv;
19013 : (void)jcls;
19014 : (void)jarg1_;
19015 : (void)jarg5_;
19016 0 : arg1 = *(GDALGroupHS **)&jarg1;
19017 0 : arg2 = 0;
19018 0 : if (jarg2) {
19019 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19020 0 : if (!arg2) return 0;
19021 : }
19022 : {
19023 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
19024 0 : if (jarg3)
19025 : {
19026 0 : arg3 = jenv->GetArrayLength(jarg3);
19027 0 : if (arg3 == 0)
19028 0 : arg4 = (GUIntBig *) NULL;
19029 : else
19030 0 : arg4 = (GUIntBig *) jenv->GetLongArrayElements(jarg3, NULL);
19031 : }
19032 : else {
19033 0 : arg3 = 0;
19034 0 : arg4 = (GUIntBig *) NULL;
19035 : }
19036 : }
19037 0 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
19038 : {
19039 0 : if (!arg2) {
19040 : {
19041 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19042 : };
19043 : }
19044 : }
19045 : {
19046 0 : if (!arg5) {
19047 : {
19048 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19049 : };
19050 : }
19051 : }
19052 0 : result = (GDALAttributeHS *)GDALGroupHS_CreateAttribute__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
19053 0 : *(GDALAttributeHS **)&jresult = result;
19054 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19055 : {
19056 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
19057 0 : if (arg4) {
19058 0 : jenv->ReleaseLongArrayElements(jarg3, (jlong*)arg4, JNI_ABORT);
19059 : }
19060 : }
19061 0 : return jresult;
19062 : }
19063 :
19064 :
19065 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteAttribute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
19066 0 : jint jresult = 0 ;
19067 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19068 0 : char *arg2 = (char *) 0 ;
19069 0 : char **arg3 = (char **) 0 ;
19070 : CPLErr result;
19071 :
19072 : (void)jenv;
19073 : (void)jcls;
19074 : (void)jarg1_;
19075 0 : arg1 = *(GDALGroupHS **)&jarg1;
19076 0 : arg2 = 0;
19077 0 : if (jarg2) {
19078 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19079 0 : if (!arg2) return 0;
19080 : }
19081 : {
19082 : /* %typemap(in) char **options */
19083 0 : arg3 = NULL;
19084 0 : if(jarg3 != 0) {
19085 0 : const jclass vector = jenv->FindClass("java/util/Vector");
19086 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
19087 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
19088 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
19089 : "()Ljava/util/Enumeration;");
19090 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
19091 : "hasMoreElements", "()Z");
19092 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
19093 : "nextElement", "()Ljava/lang/Object;");
19094 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
19095 0 : hasMoreElements == NULL || getNextElement == NULL) {
19096 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
19097 0 : return 0;
19098 : }
19099 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
19100 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
19101 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
19102 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
19103 : {
19104 0 : CSLDestroy(arg3);
19105 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
19106 0 : return 0;
19107 : }
19108 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
19109 0 : arg3 = CSLAddString(arg3, valptr);
19110 0 : jenv->ReleaseStringUTFChars(value, valptr);
19111 : }
19112 : }
19113 : }
19114 : {
19115 0 : if (!arg2) {
19116 : {
19117 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19118 : };
19119 : }
19120 : }
19121 0 : result = (CPLErr)GDALGroupHS_DeleteAttribute__SWIG_0(arg1,(char const *)arg2,arg3);
19122 0 : jresult = (jint)result;
19123 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19124 : {
19125 : /* %typemap(freearg) char **options */
19126 0 : CSLDestroy( arg3 );
19127 : }
19128 0 : return jresult;
19129 : }
19130 :
19131 :
19132 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1DeleteAttribute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19133 0 : jint jresult = 0 ;
19134 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19135 0 : char *arg2 = (char *) 0 ;
19136 : CPLErr result;
19137 :
19138 : (void)jenv;
19139 : (void)jcls;
19140 : (void)jarg1_;
19141 0 : arg1 = *(GDALGroupHS **)&jarg1;
19142 0 : arg2 = 0;
19143 0 : if (jarg2) {
19144 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19145 0 : if (!arg2) return 0;
19146 : }
19147 : {
19148 0 : if (!arg2) {
19149 : {
19150 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19151 : };
19152 : }
19153 : }
19154 0 : result = (CPLErr)GDALGroupHS_DeleteAttribute__SWIG_0(arg1,(char const *)arg2);
19155 0 : jresult = (jint)result;
19156 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19157 0 : return jresult;
19158 : }
19159 :
19160 :
19161 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Group_1Rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19162 0 : jint jresult = 0 ;
19163 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19164 0 : char *arg2 = (char *) 0 ;
19165 : CPLErr result;
19166 :
19167 : (void)jenv;
19168 : (void)jcls;
19169 : (void)jarg1_;
19170 0 : arg1 = *(GDALGroupHS **)&jarg1;
19171 0 : arg2 = 0;
19172 0 : if (jarg2) {
19173 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19174 0 : if (!arg2) return 0;
19175 : }
19176 0 : result = (CPLErr)GDALGroupHS_Rename(arg1,(char const *)arg2);
19177 0 : jresult = (jint)result;
19178 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19179 0 : return jresult;
19180 : }
19181 :
19182 :
19183 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1SubsetDimensionFromSelection_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
19184 0 : jlong jresult = 0 ;
19185 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19186 0 : char *arg2 = (char *) 0 ;
19187 0 : char **arg3 = (char **) 0 ;
19188 0 : GDALGroupHS *result = 0 ;
19189 :
19190 : (void)jenv;
19191 : (void)jcls;
19192 : (void)jarg1_;
19193 0 : arg1 = *(GDALGroupHS **)&jarg1;
19194 0 : arg2 = 0;
19195 0 : if (jarg2) {
19196 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19197 0 : if (!arg2) return 0;
19198 : }
19199 : {
19200 : /* %typemap(in) char **options */
19201 0 : arg3 = NULL;
19202 0 : if(jarg3 != 0) {
19203 0 : const jclass vector = jenv->FindClass("java/util/Vector");
19204 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
19205 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
19206 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
19207 : "()Ljava/util/Enumeration;");
19208 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
19209 : "hasMoreElements", "()Z");
19210 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
19211 : "nextElement", "()Ljava/lang/Object;");
19212 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
19213 0 : hasMoreElements == NULL || getNextElement == NULL) {
19214 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
19215 0 : return 0;
19216 : }
19217 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
19218 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
19219 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
19220 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
19221 : {
19222 0 : CSLDestroy(arg3);
19223 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
19224 0 : return 0;
19225 : }
19226 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
19227 0 : arg3 = CSLAddString(arg3, valptr);
19228 0 : jenv->ReleaseStringUTFChars(value, valptr);
19229 : }
19230 : }
19231 : }
19232 0 : result = (GDALGroupHS *)GDALGroupHS_SubsetDimensionFromSelection__SWIG_0(arg1,(char const *)arg2,arg3);
19233 0 : *(GDALGroupHS **)&jresult = result;
19234 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19235 : {
19236 : /* %typemap(freearg) char **options */
19237 0 : CSLDestroy( arg3 );
19238 : }
19239 0 : return jresult;
19240 : }
19241 :
19242 :
19243 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Group_1SubsetDimensionFromSelection_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19244 0 : jlong jresult = 0 ;
19245 0 : GDALGroupHS *arg1 = (GDALGroupHS *) 0 ;
19246 0 : char *arg2 = (char *) 0 ;
19247 0 : GDALGroupHS *result = 0 ;
19248 :
19249 : (void)jenv;
19250 : (void)jcls;
19251 : (void)jarg1_;
19252 0 : arg1 = *(GDALGroupHS **)&jarg1;
19253 0 : arg2 = 0;
19254 0 : if (jarg2) {
19255 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19256 0 : if (!arg2) return 0;
19257 : }
19258 0 : result = (GDALGroupHS *)GDALGroupHS_SubsetDimensionFromSelection__SWIG_0(arg1,(char const *)arg2);
19259 0 : *(GDALGroupHS **)&jresult = result;
19260 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19261 0 : return jresult;
19262 : }
19263 :
19264 :
19265 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_Statistics_1min_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19266 0 : jdouble jresult = 0 ;
19267 0 : Statistics *arg1 = (Statistics *) 0 ;
19268 : double result;
19269 :
19270 : (void)jenv;
19271 : (void)jcls;
19272 : (void)jarg1_;
19273 0 : arg1 = *(Statistics **)&jarg1;
19274 0 : result = (double) ((arg1)->min);
19275 0 : jresult = (jdouble)result;
19276 0 : return jresult;
19277 : }
19278 :
19279 :
19280 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_Statistics_1max_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19281 0 : jdouble jresult = 0 ;
19282 0 : Statistics *arg1 = (Statistics *) 0 ;
19283 : double result;
19284 :
19285 : (void)jenv;
19286 : (void)jcls;
19287 : (void)jarg1_;
19288 0 : arg1 = *(Statistics **)&jarg1;
19289 0 : result = (double) ((arg1)->max);
19290 0 : jresult = (jdouble)result;
19291 0 : return jresult;
19292 : }
19293 :
19294 :
19295 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_Statistics_1mean_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19296 0 : jdouble jresult = 0 ;
19297 0 : Statistics *arg1 = (Statistics *) 0 ;
19298 : double result;
19299 :
19300 : (void)jenv;
19301 : (void)jcls;
19302 : (void)jarg1_;
19303 0 : arg1 = *(Statistics **)&jarg1;
19304 0 : result = (double) ((arg1)->mean);
19305 0 : jresult = (jdouble)result;
19306 0 : return jresult;
19307 : }
19308 :
19309 :
19310 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_Statistics_1std_1dev_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19311 0 : jdouble jresult = 0 ;
19312 0 : Statistics *arg1 = (Statistics *) 0 ;
19313 : double result;
19314 :
19315 : (void)jenv;
19316 : (void)jcls;
19317 : (void)jarg1_;
19318 0 : arg1 = *(Statistics **)&jarg1;
19319 0 : result = (double) ((arg1)->std_dev);
19320 0 : jresult = (jdouble)result;
19321 0 : return jresult;
19322 : }
19323 :
19324 :
19325 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Statistics_1valid_1count_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19326 0 : jlong jresult = 0 ;
19327 0 : Statistics *arg1 = (Statistics *) 0 ;
19328 : GIntBig result;
19329 :
19330 : (void)jenv;
19331 : (void)jcls;
19332 : (void)jarg1_;
19333 0 : arg1 = *(Statistics **)&jarg1;
19334 0 : result = ((arg1)->valid_count);
19335 : {
19336 : /* %typemap(out) (GIntBig) */
19337 0 : jresult = (jlong) result;
19338 : }
19339 0 : return jresult;
19340 : }
19341 :
19342 :
19343 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Statistics(JNIEnv *jenv, jclass jcls, jlong jarg1) {
19344 0 : Statistics *arg1 = (Statistics *) 0 ;
19345 :
19346 : (void)jenv;
19347 : (void)jcls;
19348 0 : arg1 = *(Statistics **)&jarg1;
19349 0 : delete_Statistics(arg1);
19350 0 : }
19351 :
19352 :
19353 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1Statistics(JNIEnv *jenv, jclass jcls) {
19354 0 : jlong jresult = 0 ;
19355 0 : Statistics *result = 0 ;
19356 :
19357 : (void)jenv;
19358 : (void)jcls;
19359 0 : result = (Statistics *)new Statistics();
19360 0 : *(Statistics **)&jresult = result;
19361 0 : return jresult;
19362 : }
19363 :
19364 :
19365 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1MDArray(JNIEnv *jenv, jclass jcls, jlong jarg1) {
19366 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19367 :
19368 : (void)jenv;
19369 : (void)jcls;
19370 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19371 0 : delete_GDALMDArrayHS(arg1);
19372 0 : }
19373 :
19374 :
19375 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19376 0 : jstring jresult = 0 ;
19377 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19378 0 : char *result = 0 ;
19379 :
19380 : (void)jenv;
19381 : (void)jcls;
19382 : (void)jarg1_;
19383 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19384 0 : result = (char *)GDALMDArrayHS_GetName(arg1);
19385 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
19386 0 : return jresult;
19387 : }
19388 :
19389 :
19390 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetFullName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19391 0 : jstring jresult = 0 ;
19392 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19393 0 : char *result = 0 ;
19394 :
19395 : (void)jenv;
19396 : (void)jcls;
19397 : (void)jarg1_;
19398 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19399 0 : result = (char *)GDALMDArrayHS_GetFullName(arg1);
19400 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
19401 0 : return jresult;
19402 : }
19403 :
19404 :
19405 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetTotalElementsCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19406 0 : jlong jresult = 0 ;
19407 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19408 : GUIntBig result;
19409 :
19410 : (void)jenv;
19411 : (void)jcls;
19412 : (void)jarg1_;
19413 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19414 0 : result = GDALMDArrayHS_GetTotalElementsCount(arg1);
19415 : {
19416 : /* %typemap(out) (GUIntBig) */
19417 0 : jresult = (jlong) result;
19418 : }
19419 0 : return jresult;
19420 : }
19421 :
19422 :
19423 8 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetDimensionCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19424 8 : jlong jresult = 0 ;
19425 8 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19426 : size_t result;
19427 :
19428 : (void)jenv;
19429 : (void)jcls;
19430 : (void)jarg1_;
19431 8 : arg1 = *(GDALMDArrayHS **)&jarg1;
19432 8 : result = GDALMDArrayHS_GetDimensionCount(arg1);
19433 8 : jresult = (jlong)result;
19434 8 : return jresult;
19435 : }
19436 :
19437 :
19438 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetDataType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19439 0 : jlong jresult = 0 ;
19440 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19441 0 : GDALExtendedDataTypeHS *result = 0 ;
19442 :
19443 : (void)jenv;
19444 : (void)jcls;
19445 : (void)jarg1_;
19446 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19447 0 : result = (GDALExtendedDataTypeHS *)GDALMDArrayHS_GetDataType(arg1);
19448 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
19449 0 : return jresult;
19450 : }
19451 :
19452 :
19453 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetStructuralInfo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19454 0 : jobject jresult = 0 ;
19455 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19456 0 : char **result = 0 ;
19457 :
19458 : (void)jenv;
19459 : (void)jcls;
19460 : (void)jarg1_;
19461 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19462 0 : result = (char **)GDALMDArrayHS_GetStructuralInfo(arg1);
19463 : {
19464 : /* %typemap(out) char **dict */
19465 0 : jresult = GetCSLStringAsHashTable(jenv, result, false);
19466 : }
19467 0 : return jresult;
19468 : }
19469 :
19470 :
19471 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jobject jarg4) {
19472 0 : jint jresult = 0 ;
19473 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19474 : int arg2 ;
19475 0 : GUIntBig *arg3 = (GUIntBig *) 0 ;
19476 0 : char **arg4 = (char **) 0 ;
19477 : CPLErr result;
19478 :
19479 : (void)jenv;
19480 : (void)jcls;
19481 : (void)jarg1_;
19482 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19483 : {
19484 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
19485 0 : if (jarg2)
19486 : {
19487 0 : arg2 = jenv->GetArrayLength(jarg2);
19488 0 : if (arg2 == 0)
19489 0 : arg3 = (GUIntBig *) NULL;
19490 : else
19491 0 : arg3 = (GUIntBig *) jenv->GetLongArrayElements(jarg2, NULL);
19492 : }
19493 : else {
19494 0 : arg2 = 0;
19495 0 : arg3 = (GUIntBig *) NULL;
19496 : }
19497 : }
19498 : {
19499 : /* %typemap(in) char **options */
19500 0 : arg4 = NULL;
19501 0 : if(jarg4 != 0) {
19502 0 : const jclass vector = jenv->FindClass("java/util/Vector");
19503 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
19504 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
19505 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
19506 : "()Ljava/util/Enumeration;");
19507 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
19508 : "hasMoreElements", "()Z");
19509 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
19510 : "nextElement", "()Ljava/lang/Object;");
19511 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
19512 0 : hasMoreElements == NULL || getNextElement == NULL) {
19513 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
19514 0 : return 0;
19515 : }
19516 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
19517 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
19518 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
19519 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
19520 : {
19521 0 : CSLDestroy(arg4);
19522 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
19523 0 : return 0;
19524 : }
19525 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
19526 0 : arg4 = CSLAddString(arg4, valptr);
19527 0 : jenv->ReleaseStringUTFChars(value, valptr);
19528 : }
19529 : }
19530 : }
19531 0 : result = (CPLErr)GDALMDArrayHS_Resize__SWIG_0(arg1,arg2,arg3,arg4);
19532 0 : jresult = (jint)result;
19533 : {
19534 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
19535 0 : if (arg3) {
19536 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
19537 : }
19538 : }
19539 : {
19540 : /* %typemap(freearg) char **options */
19541 0 : CSLDestroy( arg4 );
19542 : }
19543 0 : return jresult;
19544 : }
19545 :
19546 :
19547 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2) {
19548 0 : jint jresult = 0 ;
19549 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19550 : int arg2 ;
19551 0 : GUIntBig *arg3 = (GUIntBig *) 0 ;
19552 : CPLErr result;
19553 :
19554 : (void)jenv;
19555 : (void)jcls;
19556 : (void)jarg1_;
19557 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19558 : {
19559 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
19560 0 : if (jarg2)
19561 : {
19562 0 : arg2 = jenv->GetArrayLength(jarg2);
19563 0 : if (arg2 == 0)
19564 0 : arg3 = (GUIntBig *) NULL;
19565 : else
19566 0 : arg3 = (GUIntBig *) jenv->GetLongArrayElements(jarg2, NULL);
19567 : }
19568 : else {
19569 0 : arg2 = 0;
19570 0 : arg3 = (GUIntBig *) NULL;
19571 : }
19572 : }
19573 0 : result = (CPLErr)GDALMDArrayHS_Resize__SWIG_0(arg1,arg2,arg3);
19574 0 : jresult = (jint)result;
19575 : {
19576 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
19577 0 : if (arg3) {
19578 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
19579 : }
19580 : }
19581 0 : return jresult;
19582 : }
19583 :
19584 :
19585 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetAttribute(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19586 0 : jlong jresult = 0 ;
19587 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19588 0 : char *arg2 = (char *) 0 ;
19589 0 : GDALAttributeHS *result = 0 ;
19590 :
19591 : (void)jenv;
19592 : (void)jcls;
19593 : (void)jarg1_;
19594 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19595 0 : arg2 = 0;
19596 0 : if (jarg2) {
19597 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19598 0 : if (!arg2) return 0;
19599 : }
19600 : {
19601 0 : if (!arg2) {
19602 : {
19603 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19604 : };
19605 : }
19606 : }
19607 0 : result = (GDALAttributeHS *)GDALMDArrayHS_GetAttribute(arg1,(char const *)arg2);
19608 0 : *(GDALAttributeHS **)&jresult = result;
19609 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19610 0 : return jresult;
19611 : }
19612 :
19613 :
19614 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1CreateAttribute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlongArray jarg3, jlong jarg5, jobject jarg5_, jobject jarg6) {
19615 0 : jlong jresult = 0 ;
19616 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19617 0 : char *arg2 = (char *) 0 ;
19618 : int arg3 ;
19619 0 : GUIntBig *arg4 = (GUIntBig *) 0 ;
19620 0 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
19621 0 : char **arg6 = (char **) 0 ;
19622 0 : GDALAttributeHS *result = 0 ;
19623 :
19624 : (void)jenv;
19625 : (void)jcls;
19626 : (void)jarg1_;
19627 : (void)jarg5_;
19628 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19629 0 : arg2 = 0;
19630 0 : if (jarg2) {
19631 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19632 0 : if (!arg2) return 0;
19633 : }
19634 : {
19635 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
19636 0 : if (jarg3)
19637 : {
19638 0 : arg3 = jenv->GetArrayLength(jarg3);
19639 0 : if (arg3 == 0)
19640 0 : arg4 = (GUIntBig *) NULL;
19641 : else
19642 0 : arg4 = (GUIntBig *) jenv->GetLongArrayElements(jarg3, NULL);
19643 : }
19644 : else {
19645 0 : arg3 = 0;
19646 0 : arg4 = (GUIntBig *) NULL;
19647 : }
19648 : }
19649 0 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
19650 : {
19651 : /* %typemap(in) char **options */
19652 0 : arg6 = NULL;
19653 0 : if(jarg6 != 0) {
19654 0 : const jclass vector = jenv->FindClass("java/util/Vector");
19655 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
19656 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
19657 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
19658 : "()Ljava/util/Enumeration;");
19659 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
19660 : "hasMoreElements", "()Z");
19661 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
19662 : "nextElement", "()Ljava/lang/Object;");
19663 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
19664 0 : hasMoreElements == NULL || getNextElement == NULL) {
19665 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
19666 0 : return 0;
19667 : }
19668 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
19669 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
19670 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
19671 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
19672 : {
19673 0 : CSLDestroy(arg6);
19674 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
19675 0 : return 0;
19676 : }
19677 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
19678 0 : arg6 = CSLAddString(arg6, valptr);
19679 0 : jenv->ReleaseStringUTFChars(value, valptr);
19680 : }
19681 : }
19682 : }
19683 : {
19684 0 : if (!arg2) {
19685 : {
19686 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19687 : };
19688 : }
19689 : }
19690 : {
19691 0 : if (!arg5) {
19692 : {
19693 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19694 : };
19695 : }
19696 : }
19697 0 : result = (GDALAttributeHS *)GDALMDArrayHS_CreateAttribute__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5,arg6);
19698 0 : *(GDALAttributeHS **)&jresult = result;
19699 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19700 : {
19701 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
19702 0 : if (arg4) {
19703 0 : jenv->ReleaseLongArrayElements(jarg3, (jlong*)arg4, JNI_ABORT);
19704 : }
19705 : }
19706 : {
19707 : /* %typemap(freearg) char **options */
19708 0 : CSLDestroy( arg6 );
19709 : }
19710 0 : return jresult;
19711 : }
19712 :
19713 :
19714 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1CreateAttribute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlongArray jarg3, jlong jarg5, jobject jarg5_) {
19715 0 : jlong jresult = 0 ;
19716 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19717 0 : char *arg2 = (char *) 0 ;
19718 : int arg3 ;
19719 0 : GUIntBig *arg4 = (GUIntBig *) 0 ;
19720 0 : GDALExtendedDataTypeHS *arg5 = (GDALExtendedDataTypeHS *) 0 ;
19721 0 : GDALAttributeHS *result = 0 ;
19722 :
19723 : (void)jenv;
19724 : (void)jcls;
19725 : (void)jarg1_;
19726 : (void)jarg5_;
19727 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19728 0 : arg2 = 0;
19729 0 : if (jarg2) {
19730 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19731 0 : if (!arg2) return 0;
19732 : }
19733 : {
19734 : /* %typemap(in, numinputs=1) (int nList, GUIntBig *pList) */
19735 0 : if (jarg3)
19736 : {
19737 0 : arg3 = jenv->GetArrayLength(jarg3);
19738 0 : if (arg3 == 0)
19739 0 : arg4 = (GUIntBig *) NULL;
19740 : else
19741 0 : arg4 = (GUIntBig *) jenv->GetLongArrayElements(jarg3, NULL);
19742 : }
19743 : else {
19744 0 : arg3 = 0;
19745 0 : arg4 = (GUIntBig *) NULL;
19746 : }
19747 : }
19748 0 : arg5 = *(GDALExtendedDataTypeHS **)&jarg5;
19749 : {
19750 0 : if (!arg2) {
19751 : {
19752 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19753 : };
19754 : }
19755 : }
19756 : {
19757 0 : if (!arg5) {
19758 : {
19759 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19760 : };
19761 : }
19762 : }
19763 0 : result = (GDALAttributeHS *)GDALMDArrayHS_CreateAttribute__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
19764 0 : *(GDALAttributeHS **)&jresult = result;
19765 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19766 : {
19767 : /* %typemap(freearg) (int nList, GUIntBig *pList) */
19768 0 : if (arg4) {
19769 0 : jenv->ReleaseLongArrayElements(jarg3, (jlong*)arg4, JNI_ABORT);
19770 : }
19771 : }
19772 0 : return jresult;
19773 : }
19774 :
19775 :
19776 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1DeleteAttribute_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jobject jarg3) {
19777 0 : jint jresult = 0 ;
19778 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19779 0 : char *arg2 = (char *) 0 ;
19780 0 : char **arg3 = (char **) 0 ;
19781 : CPLErr result;
19782 :
19783 : (void)jenv;
19784 : (void)jcls;
19785 : (void)jarg1_;
19786 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19787 0 : arg2 = 0;
19788 0 : if (jarg2) {
19789 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19790 0 : if (!arg2) return 0;
19791 : }
19792 : {
19793 : /* %typemap(in) char **options */
19794 0 : arg3 = NULL;
19795 0 : if(jarg3 != 0) {
19796 0 : const jclass vector = jenv->FindClass("java/util/Vector");
19797 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
19798 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
19799 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
19800 : "()Ljava/util/Enumeration;");
19801 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
19802 : "hasMoreElements", "()Z");
19803 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
19804 : "nextElement", "()Ljava/lang/Object;");
19805 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
19806 0 : hasMoreElements == NULL || getNextElement == NULL) {
19807 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
19808 0 : return 0;
19809 : }
19810 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
19811 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
19812 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
19813 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
19814 : {
19815 0 : CSLDestroy(arg3);
19816 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
19817 0 : return 0;
19818 : }
19819 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
19820 0 : arg3 = CSLAddString(arg3, valptr);
19821 0 : jenv->ReleaseStringUTFChars(value, valptr);
19822 : }
19823 : }
19824 : }
19825 : {
19826 0 : if (!arg2) {
19827 : {
19828 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19829 : };
19830 : }
19831 : }
19832 0 : result = (CPLErr)GDALMDArrayHS_DeleteAttribute__SWIG_0(arg1,(char const *)arg2,arg3);
19833 0 : jresult = (jint)result;
19834 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19835 : {
19836 : /* %typemap(freearg) char **options */
19837 0 : CSLDestroy( arg3 );
19838 : }
19839 0 : return jresult;
19840 : }
19841 :
19842 :
19843 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1DeleteAttribute_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19844 0 : jint jresult = 0 ;
19845 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19846 0 : char *arg2 = (char *) 0 ;
19847 : CPLErr result;
19848 :
19849 : (void)jenv;
19850 : (void)jcls;
19851 : (void)jarg1_;
19852 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19853 0 : arg2 = 0;
19854 0 : if (jarg2) {
19855 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19856 0 : if (!arg2) return 0;
19857 : }
19858 : {
19859 0 : if (!arg2) {
19860 : {
19861 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
19862 : };
19863 : }
19864 : }
19865 0 : result = (CPLErr)GDALMDArrayHS_DeleteAttribute__SWIG_0(arg1,(char const *)arg2);
19866 0 : jresult = (jint)result;
19867 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19868 0 : return jresult;
19869 : }
19870 :
19871 :
19872 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetNoDataValueAsDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
19873 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19874 0 : double *arg2 = (double *) 0 ;
19875 0 : int *arg3 = (int *) 0 ;
19876 : double tmpval2 ;
19877 : int tmphasval2 ;
19878 :
19879 : (void)jenv;
19880 : (void)jcls;
19881 : (void)jarg1_;
19882 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19883 : {
19884 : /* %typemap(in) (double *val, int*hasval) */
19885 0 : arg2 = &tmpval2;
19886 0 : arg3 = &tmphasval2;
19887 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
19888 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
19889 0 : return ;
19890 : }
19891 : }
19892 0 : GDALMDArrayHS_GetNoDataValueAsDouble(arg1,arg2,arg3);
19893 : {
19894 : /* %typemap(argout) (double *val, int*hasval) */
19895 0 : const jclass Double = jenv->FindClass("java/lang/Double");
19896 0 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
19897 : "(D)V");
19898 0 : if(*arg3) {
19899 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
19900 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
19901 : } else {
19902 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
19903 : }
19904 : }
19905 : }
19906 :
19907 :
19908 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetNoDataValueAsString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19909 0 : jstring jresult = 0 ;
19910 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19911 0 : retStringAndCPLFree *result = 0 ;
19912 :
19913 : (void)jenv;
19914 : (void)jcls;
19915 : (void)jarg1_;
19916 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19917 0 : result = (retStringAndCPLFree *)GDALMDArrayHS_GetNoDataValueAsString(arg1);
19918 : {
19919 : /* %typemap(out) (retStringAndCPLFree*) */
19920 0 : if(result)
19921 : {
19922 0 : jresult = jenv->NewStringUTF((const char *)result);
19923 0 : CPLFree(result);
19924 : }
19925 : }
19926 0 : return jresult;
19927 : }
19928 :
19929 :
19930 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetNoDataValueDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
19931 0 : jint jresult = 0 ;
19932 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19933 : double arg2 ;
19934 : CPLErr result;
19935 :
19936 : (void)jenv;
19937 : (void)jcls;
19938 : (void)jarg1_;
19939 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19940 0 : arg2 = (double)jarg2;
19941 0 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueDouble(arg1,arg2);
19942 0 : jresult = (jint)result;
19943 0 : return jresult;
19944 : }
19945 :
19946 :
19947 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetNoDataValueString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
19948 0 : jint jresult = 0 ;
19949 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19950 0 : char *arg2 = (char *) 0 ;
19951 : CPLErr result;
19952 :
19953 : (void)jenv;
19954 : (void)jcls;
19955 : (void)jarg1_;
19956 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19957 0 : arg2 = 0;
19958 0 : if (jarg2) {
19959 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
19960 0 : if (!arg2) return 0;
19961 : }
19962 0 : result = (CPLErr)GDALMDArrayHS_SetNoDataValueString(arg1,(char const *)arg2);
19963 0 : jresult = (jint)result;
19964 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
19965 0 : return jresult;
19966 : }
19967 :
19968 :
19969 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1DeleteNoDataValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
19970 0 : jint jresult = 0 ;
19971 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19972 : CPLErr result;
19973 :
19974 : (void)jenv;
19975 : (void)jcls;
19976 : (void)jarg1_;
19977 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19978 0 : result = (CPLErr)GDALMDArrayHS_DeleteNoDataValue(arg1);
19979 0 : jresult = (jint)result;
19980 0 : return jresult;
19981 : }
19982 :
19983 :
19984 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
19985 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
19986 0 : double *arg2 = (double *) 0 ;
19987 0 : int *arg3 = (int *) 0 ;
19988 : double tmpval2 ;
19989 : int tmphasval2 ;
19990 :
19991 : (void)jenv;
19992 : (void)jcls;
19993 : (void)jarg1_;
19994 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
19995 : {
19996 : /* %typemap(in) (double *val, int*hasval) */
19997 0 : arg2 = &tmpval2;
19998 0 : arg3 = &tmphasval2;
19999 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
20000 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
20001 0 : return ;
20002 : }
20003 : }
20004 0 : GDALMDArrayHS_GetOffset(arg1,arg2,arg3);
20005 : {
20006 : /* %typemap(argout) (double *val, int*hasval) */
20007 0 : const jclass Double = jenv->FindClass("java/lang/Double");
20008 0 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
20009 : "(D)V");
20010 0 : if(*arg3) {
20011 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
20012 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
20013 : } else {
20014 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
20015 : }
20016 : }
20017 : }
20018 :
20019 :
20020 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetOffsetStorageType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20021 0 : jint jresult = 0 ;
20022 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20023 : GDALDataType result;
20024 :
20025 : (void)jenv;
20026 : (void)jcls;
20027 : (void)jarg1_;
20028 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20029 0 : result = (GDALDataType)GDALMDArrayHS_GetOffsetStorageType(arg1);
20030 0 : jresult = (jint)result;
20031 0 : return jresult;
20032 : }
20033 :
20034 :
20035 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetScale(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
20036 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20037 0 : double *arg2 = (double *) 0 ;
20038 0 : int *arg3 = (int *) 0 ;
20039 : double tmpval2 ;
20040 : int tmphasval2 ;
20041 :
20042 : (void)jenv;
20043 : (void)jcls;
20044 : (void)jarg1_;
20045 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20046 : {
20047 : /* %typemap(in) (double *val, int*hasval) */
20048 0 : arg2 = &tmpval2;
20049 0 : arg3 = &tmphasval2;
20050 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
20051 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
20052 0 : return ;
20053 : }
20054 : }
20055 0 : GDALMDArrayHS_GetScale(arg1,arg2,arg3);
20056 : {
20057 : /* %typemap(argout) (double *val, int*hasval) */
20058 0 : const jclass Double = jenv->FindClass("java/lang/Double");
20059 0 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
20060 : "(D)V");
20061 0 : if(*arg3) {
20062 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
20063 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
20064 : } else {
20065 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
20066 : }
20067 : }
20068 : }
20069 :
20070 :
20071 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetScaleStorageType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20072 0 : jint jresult = 0 ;
20073 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20074 : GDALDataType result;
20075 :
20076 : (void)jenv;
20077 : (void)jcls;
20078 : (void)jarg1_;
20079 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20080 0 : result = (GDALDataType)GDALMDArrayHS_GetScaleStorageType(arg1);
20081 0 : jresult = (jint)result;
20082 0 : return jresult;
20083 : }
20084 :
20085 :
20086 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetOffset_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jint jarg3) {
20087 0 : jint jresult = 0 ;
20088 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20089 : double arg2 ;
20090 : GDALDataType arg3 ;
20091 : CPLErr result;
20092 :
20093 : (void)jenv;
20094 : (void)jcls;
20095 : (void)jarg1_;
20096 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20097 0 : arg2 = (double)jarg2;
20098 0 : arg3 = (GDALDataType)jarg3;
20099 0 : result = (CPLErr)GDALMDArrayHS_SetOffset__SWIG_0(arg1,arg2,arg3);
20100 0 : jresult = (jint)result;
20101 0 : return jresult;
20102 : }
20103 :
20104 :
20105 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetOffset_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
20106 0 : jint jresult = 0 ;
20107 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20108 : double arg2 ;
20109 : CPLErr result;
20110 :
20111 : (void)jenv;
20112 : (void)jcls;
20113 : (void)jarg1_;
20114 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20115 0 : arg2 = (double)jarg2;
20116 0 : result = (CPLErr)GDALMDArrayHS_SetOffset__SWIG_0(arg1,arg2);
20117 0 : jresult = (jint)result;
20118 0 : return jresult;
20119 : }
20120 :
20121 :
20122 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetScale_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jint jarg3) {
20123 0 : jint jresult = 0 ;
20124 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20125 : double arg2 ;
20126 : GDALDataType arg3 ;
20127 : CPLErr result;
20128 :
20129 : (void)jenv;
20130 : (void)jcls;
20131 : (void)jarg1_;
20132 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20133 0 : arg2 = (double)jarg2;
20134 0 : arg3 = (GDALDataType)jarg3;
20135 0 : result = (CPLErr)GDALMDArrayHS_SetScale__SWIG_0(arg1,arg2,arg3);
20136 0 : jresult = (jint)result;
20137 0 : return jresult;
20138 : }
20139 :
20140 :
20141 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetScale_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
20142 0 : jint jresult = 0 ;
20143 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20144 : double arg2 ;
20145 : CPLErr result;
20146 :
20147 : (void)jenv;
20148 : (void)jcls;
20149 : (void)jarg1_;
20150 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20151 0 : arg2 = (double)jarg2;
20152 0 : result = (CPLErr)GDALMDArrayHS_SetScale__SWIG_0(arg1,arg2);
20153 0 : jresult = (jint)result;
20154 0 : return jresult;
20155 : }
20156 :
20157 :
20158 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetUnit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
20159 0 : jint jresult = 0 ;
20160 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20161 0 : char *arg2 = (char *) 0 ;
20162 : CPLErr result;
20163 :
20164 : (void)jenv;
20165 : (void)jcls;
20166 : (void)jarg1_;
20167 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20168 0 : arg2 = 0;
20169 0 : if (jarg2) {
20170 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20171 0 : if (!arg2) return 0;
20172 : }
20173 0 : result = (CPLErr)GDALMDArrayHS_SetUnit(arg1,(char const *)arg2);
20174 0 : jresult = (jint)result;
20175 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20176 0 : return jresult;
20177 : }
20178 :
20179 :
20180 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetUnit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20181 0 : jstring jresult = 0 ;
20182 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20183 0 : char *result = 0 ;
20184 :
20185 : (void)jenv;
20186 : (void)jcls;
20187 : (void)jarg1_;
20188 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20189 0 : result = (char *)GDALMDArrayHS_GetUnit(arg1);
20190 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
20191 0 : return jresult;
20192 : }
20193 :
20194 :
20195 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1SetSpatialRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
20196 0 : jint jresult = 0 ;
20197 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20198 0 : OSRSpatialReferenceShadow *arg2 = (OSRSpatialReferenceShadow *) 0 ;
20199 : OGRErr result;
20200 :
20201 : (void)jenv;
20202 : (void)jcls;
20203 : (void)jarg1_;
20204 : (void)jarg2_;
20205 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20206 0 : arg2 = *(OSRSpatialReferenceShadow **)&jarg2;
20207 0 : result = (OGRErr)GDALMDArrayHS_SetSpatialRef(arg1,arg2);
20208 : {
20209 : /* %typemap(out,fragment="OGRErrMessages") OGRErr */
20210 0 : if (result != 0 && bUseExceptions) {
20211 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
20212 : OGRErrMessages(result));
20213 0 : return 0;
20214 : }
20215 0 : jresult = (jint)result;
20216 : }
20217 : {
20218 : /* %typemap(ret) OGRErr */
20219 : }
20220 0 : return jresult;
20221 : }
20222 :
20223 :
20224 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetSpatialRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20225 0 : jlong jresult = 0 ;
20226 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20227 0 : OSRSpatialReferenceShadow *result = 0 ;
20228 :
20229 : (void)jenv;
20230 : (void)jcls;
20231 : (void)jarg1_;
20232 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20233 0 : result = (OSRSpatialReferenceShadow *)GDALMDArrayHS_GetSpatialRef(arg1);
20234 0 : *(OSRSpatialReferenceShadow **)&jresult = result;
20235 0 : return jresult;
20236 : }
20237 :
20238 :
20239 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetView(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
20240 0 : jlong jresult = 0 ;
20241 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20242 0 : char *arg2 = (char *) 0 ;
20243 0 : GDALMDArrayHS *result = 0 ;
20244 :
20245 : (void)jenv;
20246 : (void)jcls;
20247 : (void)jarg1_;
20248 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20249 0 : arg2 = 0;
20250 0 : if (jarg2) {
20251 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20252 0 : if (!arg2) return 0;
20253 : }
20254 : {
20255 0 : if (!arg2) {
20256 : {
20257 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
20258 : };
20259 : }
20260 : }
20261 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetView(arg1,(char const *)arg2);
20262 0 : *(GDALMDArrayHS **)&jresult = result;
20263 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20264 0 : return jresult;
20265 : }
20266 :
20267 :
20268 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Transpose(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) {
20269 0 : jlong jresult = 0 ;
20270 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20271 : int arg2 ;
20272 0 : int *arg3 = (int *) 0 ;
20273 0 : GDALMDArrayHS *result = 0 ;
20274 :
20275 : (void)jenv;
20276 : (void)jcls;
20277 : (void)jarg1_;
20278 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20279 : {
20280 : /* %typemap(in) (int nList, int* pList) */
20281 : /* check if is List */
20282 0 : if (jarg2)
20283 : {
20284 0 : arg2 = jenv->GetArrayLength(jarg2);
20285 0 : if (arg2 == 0)
20286 0 : arg3 = NULL;
20287 : else
20288 0 : arg3 = (int *)jenv->GetIntArrayElements(jarg2, NULL);
20289 : }
20290 : else
20291 : {
20292 0 : arg2 = 0;
20293 0 : arg3 = NULL;
20294 : }
20295 : }
20296 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_Transpose(arg1,arg2,arg3);
20297 0 : *(GDALMDArrayHS **)&jresult = result;
20298 : {
20299 : /* %typemap(argout) (int nList, int* pList) */
20300 : }
20301 : {
20302 : /* %typemap(freearg) (int nList, int* pList) */
20303 0 : if (arg3) {
20304 0 : jenv->ReleaseIntArrayElements(jarg2, (jint*)arg3, JNI_ABORT);
20305 : }
20306 : }
20307 0 : return jresult;
20308 : }
20309 :
20310 :
20311 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetUnscaled(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20312 0 : jlong jresult = 0 ;
20313 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20314 0 : GDALMDArrayHS *result = 0 ;
20315 :
20316 : (void)jenv;
20317 : (void)jcls;
20318 : (void)jarg1_;
20319 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20320 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetUnscaled(arg1);
20321 0 : *(GDALMDArrayHS **)&jresult = result;
20322 0 : return jresult;
20323 : }
20324 :
20325 :
20326 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetMask_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
20327 0 : jlong jresult = 0 ;
20328 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20329 0 : char **arg2 = (char **) 0 ;
20330 0 : GDALMDArrayHS *result = 0 ;
20331 :
20332 : (void)jenv;
20333 : (void)jcls;
20334 : (void)jarg1_;
20335 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20336 : {
20337 : /* %typemap(in) char **options */
20338 0 : arg2 = NULL;
20339 0 : if(jarg2 != 0) {
20340 0 : const jclass vector = jenv->FindClass("java/util/Vector");
20341 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
20342 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
20343 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
20344 : "()Ljava/util/Enumeration;");
20345 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
20346 : "hasMoreElements", "()Z");
20347 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
20348 : "nextElement", "()Ljava/lang/Object;");
20349 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
20350 0 : hasMoreElements == NULL || getNextElement == NULL) {
20351 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
20352 0 : return 0;
20353 : }
20354 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
20355 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
20356 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
20357 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
20358 : {
20359 0 : CSLDestroy(arg2);
20360 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
20361 0 : return 0;
20362 : }
20363 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
20364 0 : arg2 = CSLAddString(arg2, valptr);
20365 0 : jenv->ReleaseStringUTFChars(value, valptr);
20366 : }
20367 : }
20368 : }
20369 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetMask__SWIG_0(arg1,arg2);
20370 0 : *(GDALMDArrayHS **)&jresult = result;
20371 : {
20372 : /* %typemap(freearg) char **options */
20373 0 : CSLDestroy( arg2 );
20374 : }
20375 0 : return jresult;
20376 : }
20377 :
20378 :
20379 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetMask_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20380 0 : jlong jresult = 0 ;
20381 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20382 0 : GDALMDArrayHS *result = 0 ;
20383 :
20384 : (void)jenv;
20385 : (void)jcls;
20386 : (void)jarg1_;
20387 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20388 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetMask__SWIG_0(arg1);
20389 0 : *(GDALMDArrayHS **)&jresult = result;
20390 0 : return jresult;
20391 : }
20392 :
20393 :
20394 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetGridded_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jobject jarg5) {
20395 0 : jlong jresult = 0 ;
20396 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20397 0 : char *arg2 = (char *) 0 ;
20398 0 : GDALMDArrayHS *arg3 = (GDALMDArrayHS *) 0 ;
20399 0 : GDALMDArrayHS *arg4 = (GDALMDArrayHS *) 0 ;
20400 0 : char **arg5 = (char **) 0 ;
20401 0 : GDALMDArrayHS *result = 0 ;
20402 :
20403 : (void)jenv;
20404 : (void)jcls;
20405 : (void)jarg1_;
20406 : (void)jarg3_;
20407 : (void)jarg4_;
20408 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20409 0 : arg2 = 0;
20410 0 : if (jarg2) {
20411 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20412 0 : if (!arg2) return 0;
20413 : }
20414 0 : arg3 = *(GDALMDArrayHS **)&jarg3;
20415 0 : arg4 = *(GDALMDArrayHS **)&jarg4;
20416 : {
20417 : /* %typemap(in) char **options */
20418 0 : arg5 = NULL;
20419 0 : if(jarg5 != 0) {
20420 0 : const jclass vector = jenv->FindClass("java/util/Vector");
20421 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
20422 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
20423 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
20424 : "()Ljava/util/Enumeration;");
20425 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
20426 : "hasMoreElements", "()Z");
20427 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
20428 : "nextElement", "()Ljava/lang/Object;");
20429 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
20430 0 : hasMoreElements == NULL || getNextElement == NULL) {
20431 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
20432 0 : return 0;
20433 : }
20434 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
20435 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
20436 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
20437 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
20438 : {
20439 0 : CSLDestroy(arg5);
20440 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
20441 0 : return 0;
20442 : }
20443 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
20444 0 : arg5 = CSLAddString(arg5, valptr);
20445 0 : jenv->ReleaseStringUTFChars(value, valptr);
20446 : }
20447 : }
20448 : }
20449 : {
20450 0 : if (!arg2) {
20451 : {
20452 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
20453 : };
20454 : }
20455 : }
20456 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetGridded__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
20457 0 : *(GDALMDArrayHS **)&jresult = result;
20458 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20459 : {
20460 : /* %typemap(freearg) char **options */
20461 0 : CSLDestroy( arg5 );
20462 : }
20463 0 : return jresult;
20464 : }
20465 :
20466 :
20467 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetGridded_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
20468 0 : jlong jresult = 0 ;
20469 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20470 0 : char *arg2 = (char *) 0 ;
20471 0 : GDALMDArrayHS *arg3 = (GDALMDArrayHS *) 0 ;
20472 0 : GDALMDArrayHS *arg4 = (GDALMDArrayHS *) 0 ;
20473 0 : GDALMDArrayHS *result = 0 ;
20474 :
20475 : (void)jenv;
20476 : (void)jcls;
20477 : (void)jarg1_;
20478 : (void)jarg3_;
20479 : (void)jarg4_;
20480 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20481 0 : arg2 = 0;
20482 0 : if (jarg2) {
20483 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20484 0 : if (!arg2) return 0;
20485 : }
20486 0 : arg3 = *(GDALMDArrayHS **)&jarg3;
20487 0 : arg4 = *(GDALMDArrayHS **)&jarg4;
20488 : {
20489 0 : if (!arg2) {
20490 : {
20491 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
20492 : };
20493 : }
20494 : }
20495 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetGridded__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
20496 0 : *(GDALMDArrayHS **)&jresult = result;
20497 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20498 0 : return jresult;
20499 : }
20500 :
20501 :
20502 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetGridded_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
20503 0 : jlong jresult = 0 ;
20504 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20505 0 : char *arg2 = (char *) 0 ;
20506 0 : GDALMDArrayHS *arg3 = (GDALMDArrayHS *) 0 ;
20507 0 : GDALMDArrayHS *result = 0 ;
20508 :
20509 : (void)jenv;
20510 : (void)jcls;
20511 : (void)jarg1_;
20512 : (void)jarg3_;
20513 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20514 0 : arg2 = 0;
20515 0 : if (jarg2) {
20516 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20517 0 : if (!arg2) return 0;
20518 : }
20519 0 : arg3 = *(GDALMDArrayHS **)&jarg3;
20520 : {
20521 0 : if (!arg2) {
20522 : {
20523 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
20524 : };
20525 : }
20526 : }
20527 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetGridded__SWIG_0(arg1,(char const *)arg2,arg3);
20528 0 : *(GDALMDArrayHS **)&jresult = result;
20529 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20530 0 : return jresult;
20531 : }
20532 :
20533 :
20534 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetGridded_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
20535 0 : jlong jresult = 0 ;
20536 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20537 0 : char *arg2 = (char *) 0 ;
20538 0 : GDALMDArrayHS *result = 0 ;
20539 :
20540 : (void)jenv;
20541 : (void)jcls;
20542 : (void)jarg1_;
20543 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20544 0 : arg2 = 0;
20545 0 : if (jarg2) {
20546 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20547 0 : if (!arg2) return 0;
20548 : }
20549 : {
20550 0 : if (!arg2) {
20551 : {
20552 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
20553 : };
20554 : }
20555 : }
20556 0 : result = (GDALMDArrayHS *)GDALMDArrayHS_GetGridded__SWIG_0(arg1,(char const *)arg2);
20557 0 : *(GDALMDArrayHS **)&jresult = result;
20558 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20559 0 : return jresult;
20560 : }
20561 :
20562 :
20563 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1AsClassicDataset_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jobject jarg5) {
20564 0 : jlong jresult = 0 ;
20565 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20566 : size_t arg2 ;
20567 : size_t arg3 ;
20568 0 : GDALGroupHS *arg4 = (GDALGroupHS *) 0 ;
20569 0 : char **arg5 = (char **) 0 ;
20570 0 : GDALDatasetShadow *result = 0 ;
20571 :
20572 : (void)jenv;
20573 : (void)jcls;
20574 : (void)jarg1_;
20575 : (void)jarg4_;
20576 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20577 0 : arg2 = (size_t)jarg2;
20578 0 : arg3 = (size_t)jarg3;
20579 0 : arg4 = *(GDALGroupHS **)&jarg4;
20580 : {
20581 : /* %typemap(in) char **options */
20582 0 : arg5 = NULL;
20583 0 : if(jarg5 != 0) {
20584 0 : const jclass vector = jenv->FindClass("java/util/Vector");
20585 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
20586 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
20587 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
20588 : "()Ljava/util/Enumeration;");
20589 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
20590 : "hasMoreElements", "()Z");
20591 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
20592 : "nextElement", "()Ljava/lang/Object;");
20593 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
20594 0 : hasMoreElements == NULL || getNextElement == NULL) {
20595 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
20596 0 : return 0;
20597 : }
20598 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
20599 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
20600 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
20601 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
20602 : {
20603 0 : CSLDestroy(arg5);
20604 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
20605 0 : return 0;
20606 : }
20607 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
20608 0 : arg5 = CSLAddString(arg5, valptr);
20609 0 : jenv->ReleaseStringUTFChars(value, valptr);
20610 : }
20611 : }
20612 : }
20613 0 : result = (GDALDatasetShadow *)GDALMDArrayHS_AsClassicDataset__SWIG_0(arg1,arg2,arg3,arg4,arg5);
20614 0 : *(GDALDatasetShadow **)&jresult = result;
20615 : {
20616 : /* %typemap(freearg) char **options */
20617 0 : CSLDestroy( arg5 );
20618 : }
20619 0 : return jresult;
20620 : }
20621 :
20622 :
20623 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1AsClassicDataset_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) {
20624 0 : jlong jresult = 0 ;
20625 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20626 : size_t arg2 ;
20627 : size_t arg3 ;
20628 0 : GDALGroupHS *arg4 = (GDALGroupHS *) 0 ;
20629 0 : GDALDatasetShadow *result = 0 ;
20630 :
20631 : (void)jenv;
20632 : (void)jcls;
20633 : (void)jarg1_;
20634 : (void)jarg4_;
20635 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20636 0 : arg2 = (size_t)jarg2;
20637 0 : arg3 = (size_t)jarg3;
20638 0 : arg4 = *(GDALGroupHS **)&jarg4;
20639 0 : result = (GDALDatasetShadow *)GDALMDArrayHS_AsClassicDataset__SWIG_0(arg1,arg2,arg3,arg4);
20640 0 : *(GDALDatasetShadow **)&jresult = result;
20641 0 : return jresult;
20642 : }
20643 :
20644 :
20645 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1AsClassicDataset_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {
20646 0 : jlong jresult = 0 ;
20647 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20648 : size_t arg2 ;
20649 : size_t arg3 ;
20650 0 : GDALDatasetShadow *result = 0 ;
20651 :
20652 : (void)jenv;
20653 : (void)jcls;
20654 : (void)jarg1_;
20655 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20656 0 : arg2 = (size_t)jarg2;
20657 0 : arg3 = (size_t)jarg3;
20658 0 : result = (GDALDatasetShadow *)GDALMDArrayHS_AsClassicDataset__SWIG_0(arg1,arg2,arg3);
20659 0 : *(GDALDatasetShadow **)&jresult = result;
20660 0 : return jresult;
20661 : }
20662 :
20663 :
20664 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetStatistics_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jboolean jarg3, jobject jarg4) {
20665 0 : jlong jresult = 0 ;
20666 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20667 : bool arg2 ;
20668 : bool arg3 ;
20669 : GDALProgressFunc arg4 ;
20670 0 : void *arg5 = (void *) 0 ;
20671 0 : Statistics *result = 0 ;
20672 :
20673 : (void)jenv;
20674 : (void)jcls;
20675 : JavaProgressData sProgressInfo;
20676 0 : sProgressInfo.jenv = jenv;
20677 0 : sProgressInfo.pJavaCallback = NULL;
20678 : (void)jarg1_;
20679 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20680 0 : arg2 = jarg2 ? true : false;
20681 0 : arg3 = jarg3 ? true : false;
20682 : {
20683 0 : if ( jarg4 != 0 ) {
20684 0 : sProgressInfo.pJavaCallback = jarg4;
20685 0 : arg4 = JavaProgressProxy;
20686 0 : arg5 = &sProgressInfo;
20687 : }
20688 : else
20689 : {
20690 0 : arg4 = NULL;
20691 0 : arg5 = NULL;
20692 : }
20693 : }
20694 0 : result = (Statistics *)GDALMDArrayHS_GetStatistics__SWIG_0(arg1,arg2,arg3,arg4,arg5);
20695 0 : *(Statistics **)&jresult = result;
20696 0 : return jresult;
20697 : }
20698 :
20699 :
20700 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetStatistics_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jboolean jarg3) {
20701 0 : jlong jresult = 0 ;
20702 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20703 : bool arg2 ;
20704 : bool arg3 ;
20705 0 : Statistics *result = 0 ;
20706 :
20707 : (void)jenv;
20708 : (void)jcls;
20709 : (void)jarg1_;
20710 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20711 0 : arg2 = jarg2 ? true : false;
20712 0 : arg3 = jarg3 ? true : false;
20713 0 : result = (Statistics *)GDALMDArrayHS_GetStatistics__SWIG_0(arg1,arg2,arg3);
20714 0 : *(Statistics **)&jresult = result;
20715 0 : return jresult;
20716 : }
20717 :
20718 :
20719 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetStatistics_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
20720 0 : jlong jresult = 0 ;
20721 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20722 : bool arg2 ;
20723 0 : Statistics *result = 0 ;
20724 :
20725 : (void)jenv;
20726 : (void)jcls;
20727 : (void)jarg1_;
20728 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20729 0 : arg2 = jarg2 ? true : false;
20730 0 : result = (Statistics *)GDALMDArrayHS_GetStatistics__SWIG_0(arg1,arg2);
20731 0 : *(Statistics **)&jresult = result;
20732 0 : return jresult;
20733 : }
20734 :
20735 :
20736 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetStatistics_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20737 0 : jlong jresult = 0 ;
20738 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20739 0 : Statistics *result = 0 ;
20740 :
20741 : (void)jenv;
20742 : (void)jcls;
20743 : (void)jarg1_;
20744 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20745 0 : result = (Statistics *)GDALMDArrayHS_GetStatistics__SWIG_0(arg1);
20746 0 : *(Statistics **)&jresult = result;
20747 0 : return jresult;
20748 : }
20749 :
20750 :
20751 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1ComputeStatistics_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jobject jarg3, jobject jarg5) {
20752 0 : jlong jresult = 0 ;
20753 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20754 : bool arg2 ;
20755 : GDALProgressFunc arg3 ;
20756 0 : void *arg4 = (void *) 0 ;
20757 0 : char **arg5 = (char **) 0 ;
20758 0 : Statistics *result = 0 ;
20759 :
20760 : (void)jenv;
20761 : (void)jcls;
20762 : JavaProgressData sProgressInfo;
20763 0 : sProgressInfo.jenv = jenv;
20764 0 : sProgressInfo.pJavaCallback = NULL;
20765 : (void)jarg1_;
20766 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20767 0 : arg2 = jarg2 ? true : false;
20768 : {
20769 0 : if ( jarg3 != 0 ) {
20770 0 : sProgressInfo.pJavaCallback = jarg3;
20771 0 : arg3 = JavaProgressProxy;
20772 0 : arg4 = &sProgressInfo;
20773 : }
20774 : else
20775 : {
20776 0 : arg3 = NULL;
20777 0 : arg4 = NULL;
20778 : }
20779 : }
20780 : {
20781 : /* %typemap(in) char **options */
20782 0 : arg5 = NULL;
20783 0 : if(jarg5 != 0) {
20784 0 : const jclass vector = jenv->FindClass("java/util/Vector");
20785 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
20786 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
20787 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
20788 : "()Ljava/util/Enumeration;");
20789 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
20790 : "hasMoreElements", "()Z");
20791 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
20792 : "nextElement", "()Ljava/lang/Object;");
20793 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
20794 0 : hasMoreElements == NULL || getNextElement == NULL) {
20795 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
20796 0 : return 0;
20797 : }
20798 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
20799 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
20800 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
20801 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
20802 : {
20803 0 : CSLDestroy(arg5);
20804 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
20805 0 : return 0;
20806 : }
20807 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
20808 0 : arg5 = CSLAddString(arg5, valptr);
20809 0 : jenv->ReleaseStringUTFChars(value, valptr);
20810 : }
20811 : }
20812 : }
20813 0 : result = (Statistics *)GDALMDArrayHS_ComputeStatistics__SWIG_0(arg1,arg2,arg3,arg4,arg5);
20814 0 : *(Statistics **)&jresult = result;
20815 : {
20816 : /* %typemap(freearg) char **options */
20817 0 : CSLDestroy( arg5 );
20818 : }
20819 0 : return jresult;
20820 : }
20821 :
20822 :
20823 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1ComputeStatistics_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jobject jarg3) {
20824 0 : jlong jresult = 0 ;
20825 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20826 : bool arg2 ;
20827 : GDALProgressFunc arg3 ;
20828 0 : void *arg4 = (void *) 0 ;
20829 0 : Statistics *result = 0 ;
20830 :
20831 : (void)jenv;
20832 : (void)jcls;
20833 : JavaProgressData sProgressInfo;
20834 0 : sProgressInfo.jenv = jenv;
20835 0 : sProgressInfo.pJavaCallback = NULL;
20836 : (void)jarg1_;
20837 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20838 0 : arg2 = jarg2 ? true : false;
20839 : {
20840 0 : if ( jarg3 != 0 ) {
20841 0 : sProgressInfo.pJavaCallback = jarg3;
20842 0 : arg3 = JavaProgressProxy;
20843 0 : arg4 = &sProgressInfo;
20844 : }
20845 : else
20846 : {
20847 0 : arg3 = NULL;
20848 0 : arg4 = NULL;
20849 : }
20850 : }
20851 0 : result = (Statistics *)GDALMDArrayHS_ComputeStatistics__SWIG_0(arg1,arg2,arg3,arg4);
20852 0 : *(Statistics **)&jresult = result;
20853 0 : return jresult;
20854 : }
20855 :
20856 :
20857 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1ComputeStatistics_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
20858 0 : jlong jresult = 0 ;
20859 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20860 : bool arg2 ;
20861 0 : Statistics *result = 0 ;
20862 :
20863 : (void)jenv;
20864 : (void)jcls;
20865 : (void)jarg1_;
20866 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20867 0 : arg2 = jarg2 ? true : false;
20868 0 : result = (Statistics *)GDALMDArrayHS_ComputeStatistics__SWIG_0(arg1,arg2);
20869 0 : *(Statistics **)&jresult = result;
20870 0 : return jresult;
20871 : }
20872 :
20873 :
20874 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1ComputeStatistics_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20875 0 : jlong jresult = 0 ;
20876 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20877 0 : Statistics *result = 0 ;
20878 :
20879 : (void)jenv;
20880 : (void)jcls;
20881 : (void)jarg1_;
20882 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20883 0 : result = (Statistics *)GDALMDArrayHS_ComputeStatistics__SWIG_0(arg1);
20884 0 : *(Statistics **)&jresult = result;
20885 0 : return jresult;
20886 : }
20887 :
20888 :
20889 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Cache_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
20890 0 : jboolean jresult = 0 ;
20891 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20892 0 : char **arg2 = (char **) 0 ;
20893 : bool result;
20894 :
20895 : (void)jenv;
20896 : (void)jcls;
20897 : (void)jarg1_;
20898 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20899 : {
20900 : /* %typemap(in) char **options */
20901 0 : arg2 = NULL;
20902 0 : if(jarg2 != 0) {
20903 0 : const jclass vector = jenv->FindClass("java/util/Vector");
20904 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
20905 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
20906 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
20907 : "()Ljava/util/Enumeration;");
20908 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
20909 : "hasMoreElements", "()Z");
20910 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
20911 : "nextElement", "()Ljava/lang/Object;");
20912 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
20913 0 : hasMoreElements == NULL || getNextElement == NULL) {
20914 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
20915 0 : return 0;
20916 : }
20917 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
20918 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
20919 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
20920 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
20921 : {
20922 0 : CSLDestroy(arg2);
20923 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
20924 0 : return 0;
20925 : }
20926 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
20927 0 : arg2 = CSLAddString(arg2, valptr);
20928 0 : jenv->ReleaseStringUTFChars(value, valptr);
20929 : }
20930 : }
20931 : }
20932 0 : result = (bool)GDALMDArrayHS_Cache__SWIG_0(arg1,arg2);
20933 0 : jresult = (jboolean)result;
20934 : {
20935 : /* %typemap(freearg) char **options */
20936 0 : CSLDestroy( arg2 );
20937 : }
20938 0 : return jresult;
20939 : }
20940 :
20941 :
20942 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Cache_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
20943 0 : jboolean jresult = 0 ;
20944 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20945 : bool result;
20946 :
20947 : (void)jenv;
20948 : (void)jcls;
20949 : (void)jarg1_;
20950 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20951 0 : result = (bool)GDALMDArrayHS_Cache__SWIG_0(arg1);
20952 0 : jresult = (jboolean)result;
20953 0 : return jresult;
20954 : }
20955 :
20956 :
20957 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
20958 0 : jint jresult = 0 ;
20959 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20960 0 : char *arg2 = (char *) 0 ;
20961 : CPLErr result;
20962 :
20963 : (void)jenv;
20964 : (void)jcls;
20965 : (void)jarg1_;
20966 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
20967 0 : arg2 = 0;
20968 0 : if (jarg2) {
20969 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
20970 0 : if (!arg2) return 0;
20971 : }
20972 0 : result = (CPLErr)GDALMDArrayHS_Rename(arg1,(char const *)arg2);
20973 0 : jresult = (jint)result;
20974 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
20975 0 : return jresult;
20976 : }
20977 :
20978 :
20979 20 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1GetDimension(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
20980 20 : jlong jresult = 0 ;
20981 20 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20982 : size_t arg2 ;
20983 20 : GDALDimensionHS *result = 0 ;
20984 :
20985 : (void)jenv;
20986 : (void)jcls;
20987 : (void)jarg1_;
20988 20 : arg1 = *(GDALMDArrayHS **)&jarg1;
20989 20 : arg2 = (size_t)jarg2;
20990 20 : result = (GDALDimensionHS *)GDALMDArrayHS_GetDimension(arg1,arg2);
20991 20 : *(GDALDimensionHS **)&jresult = result;
20992 20 : return jresult;
20993 : }
20994 :
20995 :
20996 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jbyteArray jarg10) {
20997 0 : jboolean jresult = 0 ;
20998 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
20999 : int arg2 ;
21000 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21001 : int arg4 ;
21002 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21003 : int arg6 ;
21004 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21005 : int arg8 ;
21006 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21007 0 : char *arg10 = (char *) 0 ;
21008 : size_t arg11 ;
21009 : bool result;
21010 :
21011 : (void)jenv;
21012 : (void)jcls;
21013 : (void)jarg1_;
21014 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21015 : {
21016 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21017 0 : if (jarg2)
21018 : {
21019 0 : arg2 = jenv->GetArrayLength(jarg2);
21020 0 : if (arg2 == 0)
21021 0 : arg3 = (GInt64 *) NULL;
21022 : else
21023 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21024 : }
21025 : else {
21026 0 : arg2 = 0;
21027 0 : arg3 = (GInt64 *) NULL;
21028 : }
21029 : }
21030 : {
21031 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21032 0 : if (jarg4)
21033 : {
21034 0 : arg4 = jenv->GetArrayLength(jarg4);
21035 0 : if (arg4 == 0)
21036 0 : arg5 = (GInt64 *) NULL;
21037 : else
21038 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21039 : }
21040 : else {
21041 0 : arg4 = 0;
21042 0 : arg5 = (GInt64 *) NULL;
21043 : }
21044 : }
21045 : {
21046 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21047 0 : if (jarg6)
21048 : {
21049 0 : arg6 = jenv->GetArrayLength(jarg6);
21050 0 : if (arg6 == 0)
21051 0 : arg7 = (GInt64 *) NULL;
21052 : else
21053 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21054 : }
21055 : else {
21056 0 : arg6 = 0;
21057 0 : arg7 = (GInt64 *) NULL;
21058 : }
21059 : }
21060 : {
21061 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21062 0 : if (jarg8)
21063 : {
21064 0 : arg8 = jenv->GetArrayLength(jarg8);
21065 0 : if (arg8 == 0)
21066 0 : arg9 = (GInt64 *) NULL;
21067 : else
21068 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21069 : }
21070 : else {
21071 0 : arg8 = 0;
21072 0 : arg9 = (GInt64 *) NULL;
21073 : }
21074 : }
21075 : {
21076 0 : if (jarg10 == 0)
21077 : {
21078 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21079 0 : return 0;
21080 : }
21081 :
21082 0 : arg11 = sizeof(char) * jenv->GetArrayLength(jarg10);
21083 0 : arg10 = (char*) malloc(arg11);
21084 :
21085 0 : if (arg10 == NULL)
21086 : {
21087 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21088 : "Unable to allocate temporary buffer.");
21089 0 : return 0;
21090 : }
21091 : }
21092 0 : result = (bool)GDALMDArrayHS_Read__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21093 0 : jresult = (jboolean)result;
21094 : {
21095 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21096 0 : if (arg3) {
21097 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21098 : }
21099 : }
21100 : {
21101 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21102 0 : if (arg5) {
21103 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21104 : }
21105 : }
21106 : {
21107 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21108 0 : if (arg7) {
21109 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21110 : }
21111 : }
21112 : {
21113 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21114 0 : if (arg9) {
21115 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21116 : }
21117 : }
21118 : {
21119 0 : if (result) // testing the boolean function result
21120 0 : jenv->SetByteArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jbyte*)arg10);
21121 :
21122 0 : free(arg10);
21123 : }
21124 0 : return jresult;
21125 : }
21126 :
21127 :
21128 18 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jshortArray jarg10) {
21129 18 : jboolean jresult = 0 ;
21130 18 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21131 : int arg2 ;
21132 18 : GInt64 *arg3 = (GInt64 *) 0 ;
21133 : int arg4 ;
21134 18 : GInt64 *arg5 = (GInt64 *) 0 ;
21135 : int arg6 ;
21136 18 : GInt64 *arg7 = (GInt64 *) 0 ;
21137 : int arg8 ;
21138 18 : GInt64 *arg9 = (GInt64 *) 0 ;
21139 18 : short *arg10 = (short *) 0 ;
21140 : size_t arg11 ;
21141 : bool result;
21142 :
21143 : (void)jenv;
21144 : (void)jcls;
21145 : (void)jarg1_;
21146 18 : arg1 = *(GDALMDArrayHS **)&jarg1;
21147 : {
21148 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21149 18 : if (jarg2)
21150 : {
21151 18 : arg2 = jenv->GetArrayLength(jarg2);
21152 18 : if (arg2 == 0)
21153 0 : arg3 = (GInt64 *) NULL;
21154 : else
21155 18 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21156 : }
21157 : else {
21158 0 : arg2 = 0;
21159 0 : arg3 = (GInt64 *) NULL;
21160 : }
21161 : }
21162 : {
21163 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21164 18 : if (jarg4)
21165 : {
21166 18 : arg4 = jenv->GetArrayLength(jarg4);
21167 18 : if (arg4 == 0)
21168 0 : arg5 = (GInt64 *) NULL;
21169 : else
21170 18 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21171 : }
21172 : else {
21173 0 : arg4 = 0;
21174 0 : arg5 = (GInt64 *) NULL;
21175 : }
21176 : }
21177 : {
21178 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21179 18 : if (jarg6)
21180 : {
21181 18 : arg6 = jenv->GetArrayLength(jarg6);
21182 18 : if (arg6 == 0)
21183 0 : arg7 = (GInt64 *) NULL;
21184 : else
21185 18 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21186 : }
21187 : else {
21188 0 : arg6 = 0;
21189 0 : arg7 = (GInt64 *) NULL;
21190 : }
21191 : }
21192 : {
21193 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21194 18 : if (jarg8)
21195 : {
21196 18 : arg8 = jenv->GetArrayLength(jarg8);
21197 18 : if (arg8 == 0)
21198 0 : arg9 = (GInt64 *) NULL;
21199 : else
21200 18 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21201 : }
21202 : else {
21203 0 : arg8 = 0;
21204 0 : arg9 = (GInt64 *) NULL;
21205 : }
21206 : }
21207 : {
21208 18 : if (jarg10 == 0)
21209 : {
21210 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21211 0 : return 0;
21212 : }
21213 :
21214 18 : arg11 = sizeof(short) * jenv->GetArrayLength(jarg10);
21215 18 : arg10 = (short*) malloc(arg11);
21216 :
21217 18 : if (arg10 == NULL)
21218 : {
21219 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21220 : "Unable to allocate temporary buffer.");
21221 0 : return 0;
21222 : }
21223 : }
21224 18 : result = (bool)GDALMDArrayHS_Read__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21225 18 : jresult = (jboolean)result;
21226 : {
21227 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21228 18 : if (arg3) {
21229 18 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21230 : }
21231 : }
21232 : {
21233 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21234 18 : if (arg5) {
21235 18 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21236 : }
21237 : }
21238 : {
21239 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21240 18 : if (arg7) {
21241 18 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21242 : }
21243 : }
21244 : {
21245 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21246 18 : if (arg9) {
21247 18 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21248 : }
21249 : }
21250 : {
21251 18 : if (result) // testing the boolean function result
21252 18 : jenv->SetShortArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jshort*)arg10);
21253 :
21254 18 : free(arg10);
21255 : }
21256 18 : return jresult;
21257 : }
21258 :
21259 :
21260 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jintArray jarg10) {
21261 0 : jboolean jresult = 0 ;
21262 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21263 : int arg2 ;
21264 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21265 : int arg4 ;
21266 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21267 : int arg6 ;
21268 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21269 : int arg8 ;
21270 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21271 0 : int *arg10 = (int *) 0 ;
21272 : size_t arg11 ;
21273 : bool result;
21274 :
21275 : (void)jenv;
21276 : (void)jcls;
21277 : (void)jarg1_;
21278 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21279 : {
21280 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21281 0 : if (jarg2)
21282 : {
21283 0 : arg2 = jenv->GetArrayLength(jarg2);
21284 0 : if (arg2 == 0)
21285 0 : arg3 = (GInt64 *) NULL;
21286 : else
21287 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21288 : }
21289 : else {
21290 0 : arg2 = 0;
21291 0 : arg3 = (GInt64 *) NULL;
21292 : }
21293 : }
21294 : {
21295 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21296 0 : if (jarg4)
21297 : {
21298 0 : arg4 = jenv->GetArrayLength(jarg4);
21299 0 : if (arg4 == 0)
21300 0 : arg5 = (GInt64 *) NULL;
21301 : else
21302 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21303 : }
21304 : else {
21305 0 : arg4 = 0;
21306 0 : arg5 = (GInt64 *) NULL;
21307 : }
21308 : }
21309 : {
21310 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21311 0 : if (jarg6)
21312 : {
21313 0 : arg6 = jenv->GetArrayLength(jarg6);
21314 0 : if (arg6 == 0)
21315 0 : arg7 = (GInt64 *) NULL;
21316 : else
21317 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21318 : }
21319 : else {
21320 0 : arg6 = 0;
21321 0 : arg7 = (GInt64 *) NULL;
21322 : }
21323 : }
21324 : {
21325 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21326 0 : if (jarg8)
21327 : {
21328 0 : arg8 = jenv->GetArrayLength(jarg8);
21329 0 : if (arg8 == 0)
21330 0 : arg9 = (GInt64 *) NULL;
21331 : else
21332 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21333 : }
21334 : else {
21335 0 : arg8 = 0;
21336 0 : arg9 = (GInt64 *) NULL;
21337 : }
21338 : }
21339 : {
21340 0 : if (jarg10 == 0)
21341 : {
21342 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21343 0 : return 0;
21344 : }
21345 :
21346 0 : arg11 = sizeof(int) * jenv->GetArrayLength(jarg10);
21347 0 : arg10 = (int*) malloc(arg11);
21348 :
21349 0 : if (arg10 == NULL)
21350 : {
21351 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21352 : "Unable to allocate temporary buffer.");
21353 0 : return 0;
21354 : }
21355 : }
21356 0 : result = (bool)GDALMDArrayHS_Read__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21357 0 : jresult = (jboolean)result;
21358 : {
21359 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21360 0 : if (arg3) {
21361 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21362 : }
21363 : }
21364 : {
21365 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21366 0 : if (arg5) {
21367 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21368 : }
21369 : }
21370 : {
21371 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21372 0 : if (arg7) {
21373 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21374 : }
21375 : }
21376 : {
21377 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21378 0 : if (arg9) {
21379 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21380 : }
21381 : }
21382 : {
21383 0 : if (result) // testing the boolean function result
21384 0 : jenv->SetIntArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jint*)arg10);
21385 :
21386 0 : free(arg10);
21387 : }
21388 0 : return jresult;
21389 : }
21390 :
21391 :
21392 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jlongArray jarg10) {
21393 0 : jboolean jresult = 0 ;
21394 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21395 : int arg2 ;
21396 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21397 : int arg4 ;
21398 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21399 : int arg6 ;
21400 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21401 : int arg8 ;
21402 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21403 0 : int64_t *arg10 = (int64_t *) 0 ;
21404 : size_t arg11 ;
21405 : bool result;
21406 :
21407 : (void)jenv;
21408 : (void)jcls;
21409 : (void)jarg1_;
21410 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21411 : {
21412 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21413 0 : if (jarg2)
21414 : {
21415 0 : arg2 = jenv->GetArrayLength(jarg2);
21416 0 : if (arg2 == 0)
21417 0 : arg3 = (GInt64 *) NULL;
21418 : else
21419 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21420 : }
21421 : else {
21422 0 : arg2 = 0;
21423 0 : arg3 = (GInt64 *) NULL;
21424 : }
21425 : }
21426 : {
21427 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21428 0 : if (jarg4)
21429 : {
21430 0 : arg4 = jenv->GetArrayLength(jarg4);
21431 0 : if (arg4 == 0)
21432 0 : arg5 = (GInt64 *) NULL;
21433 : else
21434 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21435 : }
21436 : else {
21437 0 : arg4 = 0;
21438 0 : arg5 = (GInt64 *) NULL;
21439 : }
21440 : }
21441 : {
21442 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21443 0 : if (jarg6)
21444 : {
21445 0 : arg6 = jenv->GetArrayLength(jarg6);
21446 0 : if (arg6 == 0)
21447 0 : arg7 = (GInt64 *) NULL;
21448 : else
21449 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21450 : }
21451 : else {
21452 0 : arg6 = 0;
21453 0 : arg7 = (GInt64 *) NULL;
21454 : }
21455 : }
21456 : {
21457 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21458 0 : if (jarg8)
21459 : {
21460 0 : arg8 = jenv->GetArrayLength(jarg8);
21461 0 : if (arg8 == 0)
21462 0 : arg9 = (GInt64 *) NULL;
21463 : else
21464 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21465 : }
21466 : else {
21467 0 : arg8 = 0;
21468 0 : arg9 = (GInt64 *) NULL;
21469 : }
21470 : }
21471 : {
21472 0 : if (jarg10 == 0)
21473 : {
21474 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21475 0 : return 0;
21476 : }
21477 :
21478 0 : arg11 = sizeof(int64_t) * jenv->GetArrayLength(jarg10);
21479 0 : arg10 = (int64_t*) malloc(arg11);
21480 :
21481 0 : if (arg10 == NULL)
21482 : {
21483 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21484 : "Unable to allocate temporary buffer.");
21485 0 : return 0;
21486 : }
21487 : }
21488 0 : result = (bool)GDALMDArrayHS_Read__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21489 0 : jresult = (jboolean)result;
21490 : {
21491 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21492 0 : if (arg3) {
21493 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21494 : }
21495 : }
21496 : {
21497 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21498 0 : if (arg5) {
21499 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21500 : }
21501 : }
21502 : {
21503 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21504 0 : if (arg7) {
21505 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21506 : }
21507 : }
21508 : {
21509 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21510 0 : if (arg9) {
21511 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21512 : }
21513 : }
21514 : {
21515 0 : if (result) // testing the boolean function result
21516 0 : jenv->SetLongArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jlong*)arg10);
21517 :
21518 0 : free(arg10);
21519 : }
21520 0 : return jresult;
21521 : }
21522 :
21523 :
21524 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jfloatArray jarg10) {
21525 0 : jboolean jresult = 0 ;
21526 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21527 : int arg2 ;
21528 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21529 : int arg4 ;
21530 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21531 : int arg6 ;
21532 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21533 : int arg8 ;
21534 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21535 0 : float *arg10 = (float *) 0 ;
21536 : size_t arg11 ;
21537 : bool result;
21538 :
21539 : (void)jenv;
21540 : (void)jcls;
21541 : (void)jarg1_;
21542 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21543 : {
21544 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21545 0 : if (jarg2)
21546 : {
21547 0 : arg2 = jenv->GetArrayLength(jarg2);
21548 0 : if (arg2 == 0)
21549 0 : arg3 = (GInt64 *) NULL;
21550 : else
21551 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21552 : }
21553 : else {
21554 0 : arg2 = 0;
21555 0 : arg3 = (GInt64 *) NULL;
21556 : }
21557 : }
21558 : {
21559 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21560 0 : if (jarg4)
21561 : {
21562 0 : arg4 = jenv->GetArrayLength(jarg4);
21563 0 : if (arg4 == 0)
21564 0 : arg5 = (GInt64 *) NULL;
21565 : else
21566 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21567 : }
21568 : else {
21569 0 : arg4 = 0;
21570 0 : arg5 = (GInt64 *) NULL;
21571 : }
21572 : }
21573 : {
21574 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21575 0 : if (jarg6)
21576 : {
21577 0 : arg6 = jenv->GetArrayLength(jarg6);
21578 0 : if (arg6 == 0)
21579 0 : arg7 = (GInt64 *) NULL;
21580 : else
21581 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21582 : }
21583 : else {
21584 0 : arg6 = 0;
21585 0 : arg7 = (GInt64 *) NULL;
21586 : }
21587 : }
21588 : {
21589 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21590 0 : if (jarg8)
21591 : {
21592 0 : arg8 = jenv->GetArrayLength(jarg8);
21593 0 : if (arg8 == 0)
21594 0 : arg9 = (GInt64 *) NULL;
21595 : else
21596 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21597 : }
21598 : else {
21599 0 : arg8 = 0;
21600 0 : arg9 = (GInt64 *) NULL;
21601 : }
21602 : }
21603 : {
21604 0 : if (jarg10 == 0)
21605 : {
21606 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21607 0 : return 0;
21608 : }
21609 :
21610 0 : arg11 = sizeof(float) * jenv->GetArrayLength(jarg10);
21611 0 : arg10 = (float*) malloc(arg11);
21612 :
21613 0 : if (arg10 == NULL)
21614 : {
21615 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21616 : "Unable to allocate temporary buffer.");
21617 0 : return 0;
21618 : }
21619 : }
21620 0 : result = (bool)GDALMDArrayHS_Read__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21621 0 : jresult = (jboolean)result;
21622 : {
21623 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21624 0 : if (arg3) {
21625 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21626 : }
21627 : }
21628 : {
21629 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21630 0 : if (arg5) {
21631 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21632 : }
21633 : }
21634 : {
21635 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21636 0 : if (arg7) {
21637 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21638 : }
21639 : }
21640 : {
21641 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21642 0 : if (arg9) {
21643 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21644 : }
21645 : }
21646 : {
21647 0 : if (result) // testing the boolean function result
21648 0 : jenv->SetFloatArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jfloat*)arg10);
21649 :
21650 0 : free(arg10);
21651 : }
21652 0 : return jresult;
21653 : }
21654 :
21655 :
21656 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Read_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jdoubleArray jarg10) {
21657 0 : jboolean jresult = 0 ;
21658 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21659 : int arg2 ;
21660 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21661 : int arg4 ;
21662 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21663 : int arg6 ;
21664 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21665 : int arg8 ;
21666 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21667 0 : double *arg10 = (double *) 0 ;
21668 : size_t arg11 ;
21669 : bool result;
21670 :
21671 : (void)jenv;
21672 : (void)jcls;
21673 : (void)jarg1_;
21674 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21675 : {
21676 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21677 0 : if (jarg2)
21678 : {
21679 0 : arg2 = jenv->GetArrayLength(jarg2);
21680 0 : if (arg2 == 0)
21681 0 : arg3 = (GInt64 *) NULL;
21682 : else
21683 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21684 : }
21685 : else {
21686 0 : arg2 = 0;
21687 0 : arg3 = (GInt64 *) NULL;
21688 : }
21689 : }
21690 : {
21691 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21692 0 : if (jarg4)
21693 : {
21694 0 : arg4 = jenv->GetArrayLength(jarg4);
21695 0 : if (arg4 == 0)
21696 0 : arg5 = (GInt64 *) NULL;
21697 : else
21698 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21699 : }
21700 : else {
21701 0 : arg4 = 0;
21702 0 : arg5 = (GInt64 *) NULL;
21703 : }
21704 : }
21705 : {
21706 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21707 0 : if (jarg6)
21708 : {
21709 0 : arg6 = jenv->GetArrayLength(jarg6);
21710 0 : if (arg6 == 0)
21711 0 : arg7 = (GInt64 *) NULL;
21712 : else
21713 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21714 : }
21715 : else {
21716 0 : arg6 = 0;
21717 0 : arg7 = (GInt64 *) NULL;
21718 : }
21719 : }
21720 : {
21721 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21722 0 : if (jarg8)
21723 : {
21724 0 : arg8 = jenv->GetArrayLength(jarg8);
21725 0 : if (arg8 == 0)
21726 0 : arg9 = (GInt64 *) NULL;
21727 : else
21728 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21729 : }
21730 : else {
21731 0 : arg8 = 0;
21732 0 : arg9 = (GInt64 *) NULL;
21733 : }
21734 : }
21735 : {
21736 0 : if (jarg10 == 0)
21737 : {
21738 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21739 0 : return 0;
21740 : }
21741 :
21742 0 : arg11 = sizeof(double) * jenv->GetArrayLength(jarg10);
21743 0 : arg10 = (double*) malloc(arg11);
21744 :
21745 0 : if (arg10 == NULL)
21746 : {
21747 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21748 : "Unable to allocate temporary buffer.");
21749 0 : return 0;
21750 : }
21751 : }
21752 0 : result = (bool)GDALMDArrayHS_Read__SWIG_5(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21753 0 : jresult = (jboolean)result;
21754 : {
21755 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21756 0 : if (arg3) {
21757 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21758 : }
21759 : }
21760 : {
21761 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21762 0 : if (arg5) {
21763 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21764 : }
21765 : }
21766 : {
21767 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21768 0 : if (arg7) {
21769 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21770 : }
21771 : }
21772 : {
21773 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21774 0 : if (arg9) {
21775 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21776 : }
21777 : }
21778 : {
21779 0 : if (result) // testing the boolean function result
21780 0 : jenv->SetDoubleArrayRegion(jarg10, (jsize)0, jenv->GetArrayLength(jarg10), (jdouble*)arg10);
21781 :
21782 0 : free(arg10);
21783 : }
21784 0 : return jresult;
21785 : }
21786 :
21787 :
21788 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jbyteArray jarg10) {
21789 0 : jboolean jresult = 0 ;
21790 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21791 : int arg2 ;
21792 0 : GInt64 *arg3 = (GInt64 *) 0 ;
21793 : int arg4 ;
21794 0 : GInt64 *arg5 = (GInt64 *) 0 ;
21795 : int arg6 ;
21796 0 : GInt64 *arg7 = (GInt64 *) 0 ;
21797 : int arg8 ;
21798 0 : GInt64 *arg9 = (GInt64 *) 0 ;
21799 0 : char *arg10 = (char *) 0 ;
21800 : size_t arg11 ;
21801 : bool result;
21802 :
21803 : (void)jenv;
21804 : (void)jcls;
21805 : (void)jarg1_;
21806 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
21807 : {
21808 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21809 0 : if (jarg2)
21810 : {
21811 0 : arg2 = jenv->GetArrayLength(jarg2);
21812 0 : if (arg2 == 0)
21813 0 : arg3 = (GInt64 *) NULL;
21814 : else
21815 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21816 : }
21817 : else {
21818 0 : arg2 = 0;
21819 0 : arg3 = (GInt64 *) NULL;
21820 : }
21821 : }
21822 : {
21823 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21824 0 : if (jarg4)
21825 : {
21826 0 : arg4 = jenv->GetArrayLength(jarg4);
21827 0 : if (arg4 == 0)
21828 0 : arg5 = (GInt64 *) NULL;
21829 : else
21830 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21831 : }
21832 : else {
21833 0 : arg4 = 0;
21834 0 : arg5 = (GInt64 *) NULL;
21835 : }
21836 : }
21837 : {
21838 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21839 0 : if (jarg6)
21840 : {
21841 0 : arg6 = jenv->GetArrayLength(jarg6);
21842 0 : if (arg6 == 0)
21843 0 : arg7 = (GInt64 *) NULL;
21844 : else
21845 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21846 : }
21847 : else {
21848 0 : arg6 = 0;
21849 0 : arg7 = (GInt64 *) NULL;
21850 : }
21851 : }
21852 : {
21853 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21854 0 : if (jarg8)
21855 : {
21856 0 : arg8 = jenv->GetArrayLength(jarg8);
21857 0 : if (arg8 == 0)
21858 0 : arg9 = (GInt64 *) NULL;
21859 : else
21860 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21861 : }
21862 : else {
21863 0 : arg8 = 0;
21864 0 : arg9 = (GInt64 *) NULL;
21865 : }
21866 : }
21867 : {
21868 0 : if (jarg10 == 0)
21869 : {
21870 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21871 0 : return 0;
21872 : }
21873 :
21874 0 : arg11 = sizeof(char) * jenv->GetArrayLength(jarg10);
21875 0 : arg10 = (char*) jenv->GetByteArrayElements(jarg10, 0);
21876 0 : if (arg10 == NULL)
21877 : {
21878 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
21879 : "Unable to get buffer.");
21880 0 : return 0;
21881 : }
21882 : }
21883 0 : result = (bool)GDALMDArrayHS_Write__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
21884 0 : jresult = (jboolean)result;
21885 : {
21886 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21887 0 : if (arg3) {
21888 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
21889 : }
21890 : }
21891 : {
21892 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21893 0 : if (arg5) {
21894 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
21895 : }
21896 : }
21897 : {
21898 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21899 0 : if (arg7) {
21900 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
21901 : }
21902 : }
21903 : {
21904 : /* %typemap(freearg) (int nList, GInt64 *pList) */
21905 0 : if (arg9) {
21906 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
21907 : }
21908 : }
21909 : {
21910 0 : jenv->ReleaseByteArrayElements(jarg10, (jbyte*) arg10, JNI_ABORT);
21911 : }
21912 0 : return jresult;
21913 : }
21914 :
21915 :
21916 18 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jshortArray jarg10) {
21917 18 : jboolean jresult = 0 ;
21918 18 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
21919 : int arg2 ;
21920 18 : GInt64 *arg3 = (GInt64 *) 0 ;
21921 : int arg4 ;
21922 18 : GInt64 *arg5 = (GInt64 *) 0 ;
21923 : int arg6 ;
21924 18 : GInt64 *arg7 = (GInt64 *) 0 ;
21925 : int arg8 ;
21926 18 : GInt64 *arg9 = (GInt64 *) 0 ;
21927 18 : short *arg10 = (short *) 0 ;
21928 : size_t arg11 ;
21929 : bool result;
21930 :
21931 : (void)jenv;
21932 : (void)jcls;
21933 : (void)jarg1_;
21934 18 : arg1 = *(GDALMDArrayHS **)&jarg1;
21935 : {
21936 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21937 18 : if (jarg2)
21938 : {
21939 18 : arg2 = jenv->GetArrayLength(jarg2);
21940 18 : if (arg2 == 0)
21941 0 : arg3 = (GInt64 *) NULL;
21942 : else
21943 18 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
21944 : }
21945 : else {
21946 0 : arg2 = 0;
21947 0 : arg3 = (GInt64 *) NULL;
21948 : }
21949 : }
21950 : {
21951 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21952 18 : if (jarg4)
21953 : {
21954 18 : arg4 = jenv->GetArrayLength(jarg4);
21955 18 : if (arg4 == 0)
21956 0 : arg5 = (GInt64 *) NULL;
21957 : else
21958 18 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
21959 : }
21960 : else {
21961 0 : arg4 = 0;
21962 0 : arg5 = (GInt64 *) NULL;
21963 : }
21964 : }
21965 : {
21966 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21967 18 : if (jarg6)
21968 : {
21969 18 : arg6 = jenv->GetArrayLength(jarg6);
21970 18 : if (arg6 == 0)
21971 0 : arg7 = (GInt64 *) NULL;
21972 : else
21973 18 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
21974 : }
21975 : else {
21976 0 : arg6 = 0;
21977 0 : arg7 = (GInt64 *) NULL;
21978 : }
21979 : }
21980 : {
21981 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
21982 18 : if (jarg8)
21983 : {
21984 18 : arg8 = jenv->GetArrayLength(jarg8);
21985 18 : if (arg8 == 0)
21986 0 : arg9 = (GInt64 *) NULL;
21987 : else
21988 18 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
21989 : }
21990 : else {
21991 0 : arg8 = 0;
21992 0 : arg9 = (GInt64 *) NULL;
21993 : }
21994 : }
21995 : {
21996 18 : if (jarg10 == 0)
21997 : {
21998 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
21999 0 : return 0;
22000 : }
22001 :
22002 18 : arg11 = sizeof(short) * jenv->GetArrayLength(jarg10);
22003 18 : arg10 = (short*) jenv->GetShortArrayElements(jarg10, 0);
22004 18 : if (arg10 == NULL)
22005 : {
22006 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
22007 : "Unable to get buffer.");
22008 0 : return 0;
22009 : }
22010 : }
22011 18 : result = (bool)GDALMDArrayHS_Write__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22012 18 : jresult = (jboolean)result;
22013 : {
22014 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22015 18 : if (arg3) {
22016 18 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
22017 : }
22018 : }
22019 : {
22020 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22021 18 : if (arg5) {
22022 18 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
22023 : }
22024 : }
22025 : {
22026 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22027 18 : if (arg7) {
22028 18 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
22029 : }
22030 : }
22031 : {
22032 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22033 18 : if (arg9) {
22034 18 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
22035 : }
22036 : }
22037 : {
22038 18 : jenv->ReleaseShortArrayElements(jarg10, (jshort*) arg10, JNI_ABORT);
22039 : }
22040 18 : return jresult;
22041 : }
22042 :
22043 :
22044 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jintArray jarg10) {
22045 0 : jboolean jresult = 0 ;
22046 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
22047 : int arg2 ;
22048 0 : GInt64 *arg3 = (GInt64 *) 0 ;
22049 : int arg4 ;
22050 0 : GInt64 *arg5 = (GInt64 *) 0 ;
22051 : int arg6 ;
22052 0 : GInt64 *arg7 = (GInt64 *) 0 ;
22053 : int arg8 ;
22054 0 : GInt64 *arg9 = (GInt64 *) 0 ;
22055 0 : int *arg10 = (int *) 0 ;
22056 : size_t arg11 ;
22057 : bool result;
22058 :
22059 : (void)jenv;
22060 : (void)jcls;
22061 : (void)jarg1_;
22062 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
22063 : {
22064 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22065 0 : if (jarg2)
22066 : {
22067 0 : arg2 = jenv->GetArrayLength(jarg2);
22068 0 : if (arg2 == 0)
22069 0 : arg3 = (GInt64 *) NULL;
22070 : else
22071 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
22072 : }
22073 : else {
22074 0 : arg2 = 0;
22075 0 : arg3 = (GInt64 *) NULL;
22076 : }
22077 : }
22078 : {
22079 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22080 0 : if (jarg4)
22081 : {
22082 0 : arg4 = jenv->GetArrayLength(jarg4);
22083 0 : if (arg4 == 0)
22084 0 : arg5 = (GInt64 *) NULL;
22085 : else
22086 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
22087 : }
22088 : else {
22089 0 : arg4 = 0;
22090 0 : arg5 = (GInt64 *) NULL;
22091 : }
22092 : }
22093 : {
22094 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22095 0 : if (jarg6)
22096 : {
22097 0 : arg6 = jenv->GetArrayLength(jarg6);
22098 0 : if (arg6 == 0)
22099 0 : arg7 = (GInt64 *) NULL;
22100 : else
22101 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
22102 : }
22103 : else {
22104 0 : arg6 = 0;
22105 0 : arg7 = (GInt64 *) NULL;
22106 : }
22107 : }
22108 : {
22109 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22110 0 : if (jarg8)
22111 : {
22112 0 : arg8 = jenv->GetArrayLength(jarg8);
22113 0 : if (arg8 == 0)
22114 0 : arg9 = (GInt64 *) NULL;
22115 : else
22116 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
22117 : }
22118 : else {
22119 0 : arg8 = 0;
22120 0 : arg9 = (GInt64 *) NULL;
22121 : }
22122 : }
22123 : {
22124 0 : if (jarg10 == 0)
22125 : {
22126 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
22127 0 : return 0;
22128 : }
22129 :
22130 0 : arg11 = sizeof(int) * jenv->GetArrayLength(jarg10);
22131 0 : arg10 = (int*) jenv->GetIntArrayElements(jarg10, 0);
22132 0 : if (arg10 == NULL)
22133 : {
22134 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
22135 : "Unable to get buffer.");
22136 0 : return 0;
22137 : }
22138 : }
22139 0 : result = (bool)GDALMDArrayHS_Write__SWIG_2(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22140 0 : jresult = (jboolean)result;
22141 : {
22142 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22143 0 : if (arg3) {
22144 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
22145 : }
22146 : }
22147 : {
22148 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22149 0 : if (arg5) {
22150 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
22151 : }
22152 : }
22153 : {
22154 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22155 0 : if (arg7) {
22156 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
22157 : }
22158 : }
22159 : {
22160 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22161 0 : if (arg9) {
22162 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
22163 : }
22164 : }
22165 : {
22166 0 : jenv->ReleaseIntArrayElements(jarg10, (jint*) arg10, JNI_ABORT);
22167 : }
22168 0 : return jresult;
22169 : }
22170 :
22171 :
22172 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jlongArray jarg10) {
22173 0 : jboolean jresult = 0 ;
22174 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
22175 : int arg2 ;
22176 0 : GInt64 *arg3 = (GInt64 *) 0 ;
22177 : int arg4 ;
22178 0 : GInt64 *arg5 = (GInt64 *) 0 ;
22179 : int arg6 ;
22180 0 : GInt64 *arg7 = (GInt64 *) 0 ;
22181 : int arg8 ;
22182 0 : GInt64 *arg9 = (GInt64 *) 0 ;
22183 0 : int64_t *arg10 = (int64_t *) 0 ;
22184 : size_t arg11 ;
22185 : bool result;
22186 :
22187 : (void)jenv;
22188 : (void)jcls;
22189 : (void)jarg1_;
22190 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
22191 : {
22192 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22193 0 : if (jarg2)
22194 : {
22195 0 : arg2 = jenv->GetArrayLength(jarg2);
22196 0 : if (arg2 == 0)
22197 0 : arg3 = (GInt64 *) NULL;
22198 : else
22199 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
22200 : }
22201 : else {
22202 0 : arg2 = 0;
22203 0 : arg3 = (GInt64 *) NULL;
22204 : }
22205 : }
22206 : {
22207 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22208 0 : if (jarg4)
22209 : {
22210 0 : arg4 = jenv->GetArrayLength(jarg4);
22211 0 : if (arg4 == 0)
22212 0 : arg5 = (GInt64 *) NULL;
22213 : else
22214 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
22215 : }
22216 : else {
22217 0 : arg4 = 0;
22218 0 : arg5 = (GInt64 *) NULL;
22219 : }
22220 : }
22221 : {
22222 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22223 0 : if (jarg6)
22224 : {
22225 0 : arg6 = jenv->GetArrayLength(jarg6);
22226 0 : if (arg6 == 0)
22227 0 : arg7 = (GInt64 *) NULL;
22228 : else
22229 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
22230 : }
22231 : else {
22232 0 : arg6 = 0;
22233 0 : arg7 = (GInt64 *) NULL;
22234 : }
22235 : }
22236 : {
22237 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22238 0 : if (jarg8)
22239 : {
22240 0 : arg8 = jenv->GetArrayLength(jarg8);
22241 0 : if (arg8 == 0)
22242 0 : arg9 = (GInt64 *) NULL;
22243 : else
22244 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
22245 : }
22246 : else {
22247 0 : arg8 = 0;
22248 0 : arg9 = (GInt64 *) NULL;
22249 : }
22250 : }
22251 : {
22252 0 : if (jarg10 == 0)
22253 : {
22254 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
22255 0 : return 0;
22256 : }
22257 :
22258 0 : arg11 = sizeof(int64_t) * jenv->GetArrayLength(jarg10);
22259 0 : arg10 = (int64_t*) jenv->GetLongArrayElements(jarg10, 0);
22260 0 : if (arg10 == NULL)
22261 : {
22262 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
22263 : "Unable to get buffer.");
22264 0 : return 0;
22265 : }
22266 : }
22267 0 : result = (bool)GDALMDArrayHS_Write__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22268 0 : jresult = (jboolean)result;
22269 : {
22270 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22271 0 : if (arg3) {
22272 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
22273 : }
22274 : }
22275 : {
22276 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22277 0 : if (arg5) {
22278 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
22279 : }
22280 : }
22281 : {
22282 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22283 0 : if (arg7) {
22284 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
22285 : }
22286 : }
22287 : {
22288 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22289 0 : if (arg9) {
22290 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
22291 : }
22292 : }
22293 : {
22294 0 : jenv->ReleaseLongArrayElements(jarg10, (jlong*) arg10, JNI_ABORT);
22295 : }
22296 0 : return jresult;
22297 : }
22298 :
22299 :
22300 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jfloatArray jarg10) {
22301 0 : jboolean jresult = 0 ;
22302 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
22303 : int arg2 ;
22304 0 : GInt64 *arg3 = (GInt64 *) 0 ;
22305 : int arg4 ;
22306 0 : GInt64 *arg5 = (GInt64 *) 0 ;
22307 : int arg6 ;
22308 0 : GInt64 *arg7 = (GInt64 *) 0 ;
22309 : int arg8 ;
22310 0 : GInt64 *arg9 = (GInt64 *) 0 ;
22311 0 : float *arg10 = (float *) 0 ;
22312 : size_t arg11 ;
22313 : bool result;
22314 :
22315 : (void)jenv;
22316 : (void)jcls;
22317 : (void)jarg1_;
22318 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
22319 : {
22320 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22321 0 : if (jarg2)
22322 : {
22323 0 : arg2 = jenv->GetArrayLength(jarg2);
22324 0 : if (arg2 == 0)
22325 0 : arg3 = (GInt64 *) NULL;
22326 : else
22327 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
22328 : }
22329 : else {
22330 0 : arg2 = 0;
22331 0 : arg3 = (GInt64 *) NULL;
22332 : }
22333 : }
22334 : {
22335 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22336 0 : if (jarg4)
22337 : {
22338 0 : arg4 = jenv->GetArrayLength(jarg4);
22339 0 : if (arg4 == 0)
22340 0 : arg5 = (GInt64 *) NULL;
22341 : else
22342 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
22343 : }
22344 : else {
22345 0 : arg4 = 0;
22346 0 : arg5 = (GInt64 *) NULL;
22347 : }
22348 : }
22349 : {
22350 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22351 0 : if (jarg6)
22352 : {
22353 0 : arg6 = jenv->GetArrayLength(jarg6);
22354 0 : if (arg6 == 0)
22355 0 : arg7 = (GInt64 *) NULL;
22356 : else
22357 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
22358 : }
22359 : else {
22360 0 : arg6 = 0;
22361 0 : arg7 = (GInt64 *) NULL;
22362 : }
22363 : }
22364 : {
22365 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22366 0 : if (jarg8)
22367 : {
22368 0 : arg8 = jenv->GetArrayLength(jarg8);
22369 0 : if (arg8 == 0)
22370 0 : arg9 = (GInt64 *) NULL;
22371 : else
22372 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
22373 : }
22374 : else {
22375 0 : arg8 = 0;
22376 0 : arg9 = (GInt64 *) NULL;
22377 : }
22378 : }
22379 : {
22380 0 : if (jarg10 == 0)
22381 : {
22382 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
22383 0 : return 0;
22384 : }
22385 :
22386 0 : arg11 = sizeof(float) * jenv->GetArrayLength(jarg10);
22387 0 : arg10 = (float*) jenv->GetFloatArrayElements(jarg10, 0);
22388 0 : if (arg10 == NULL)
22389 : {
22390 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
22391 : "Unable to get buffer.");
22392 0 : return 0;
22393 : }
22394 : }
22395 0 : result = (bool)GDALMDArrayHS_Write__SWIG_4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22396 0 : jresult = (jboolean)result;
22397 : {
22398 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22399 0 : if (arg3) {
22400 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
22401 : }
22402 : }
22403 : {
22404 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22405 0 : if (arg5) {
22406 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
22407 : }
22408 : }
22409 : {
22410 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22411 0 : if (arg7) {
22412 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
22413 : }
22414 : }
22415 : {
22416 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22417 0 : if (arg9) {
22418 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
22419 : }
22420 : }
22421 : {
22422 0 : jenv->ReleaseFloatArrayElements(jarg10, (jfloat*) arg10, JNI_ABORT);
22423 : }
22424 0 : return jresult;
22425 : }
22426 :
22427 :
22428 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_MDArray_1Write_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlongArray jarg2, jlongArray jarg4, jlongArray jarg6, jlongArray jarg8, jdoubleArray jarg10) {
22429 0 : jboolean jresult = 0 ;
22430 0 : GDALMDArrayHS *arg1 = (GDALMDArrayHS *) 0 ;
22431 : int arg2 ;
22432 0 : GInt64 *arg3 = (GInt64 *) 0 ;
22433 : int arg4 ;
22434 0 : GInt64 *arg5 = (GInt64 *) 0 ;
22435 : int arg6 ;
22436 0 : GInt64 *arg7 = (GInt64 *) 0 ;
22437 : int arg8 ;
22438 0 : GInt64 *arg9 = (GInt64 *) 0 ;
22439 0 : double *arg10 = (double *) 0 ;
22440 : size_t arg11 ;
22441 : bool result;
22442 :
22443 : (void)jenv;
22444 : (void)jcls;
22445 : (void)jarg1_;
22446 0 : arg1 = *(GDALMDArrayHS **)&jarg1;
22447 : {
22448 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22449 0 : if (jarg2)
22450 : {
22451 0 : arg2 = jenv->GetArrayLength(jarg2);
22452 0 : if (arg2 == 0)
22453 0 : arg3 = (GInt64 *) NULL;
22454 : else
22455 0 : arg3 = (GInt64 *) jenv->GetLongArrayElements(jarg2, NULL);
22456 : }
22457 : else {
22458 0 : arg2 = 0;
22459 0 : arg3 = (GInt64 *) NULL;
22460 : }
22461 : }
22462 : {
22463 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22464 0 : if (jarg4)
22465 : {
22466 0 : arg4 = jenv->GetArrayLength(jarg4);
22467 0 : if (arg4 == 0)
22468 0 : arg5 = (GInt64 *) NULL;
22469 : else
22470 0 : arg5 = (GInt64 *) jenv->GetLongArrayElements(jarg4, NULL);
22471 : }
22472 : else {
22473 0 : arg4 = 0;
22474 0 : arg5 = (GInt64 *) NULL;
22475 : }
22476 : }
22477 : {
22478 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22479 0 : if (jarg6)
22480 : {
22481 0 : arg6 = jenv->GetArrayLength(jarg6);
22482 0 : if (arg6 == 0)
22483 0 : arg7 = (GInt64 *) NULL;
22484 : else
22485 0 : arg7 = (GInt64 *) jenv->GetLongArrayElements(jarg6, NULL);
22486 : }
22487 : else {
22488 0 : arg6 = 0;
22489 0 : arg7 = (GInt64 *) NULL;
22490 : }
22491 : }
22492 : {
22493 : /* %typemap(in, numinputs=1) (int nList, GInt64 *pList) */
22494 0 : if (jarg8)
22495 : {
22496 0 : arg8 = jenv->GetArrayLength(jarg8);
22497 0 : if (arg8 == 0)
22498 0 : arg9 = (GInt64 *) NULL;
22499 : else
22500 0 : arg9 = (GInt64 *) jenv->GetLongArrayElements(jarg8, NULL);
22501 : }
22502 : else {
22503 0 : arg8 = 0;
22504 0 : arg9 = (GInt64 *) NULL;
22505 : }
22506 : }
22507 : {
22508 0 : if (jarg10 == 0)
22509 : {
22510 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
22511 0 : return 0;
22512 : }
22513 :
22514 0 : arg11 = sizeof(double) * jenv->GetArrayLength(jarg10);
22515 0 : arg10 = (double*) jenv->GetDoubleArrayElements(jarg10, 0);
22516 0 : if (arg10 == NULL)
22517 : {
22518 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
22519 : "Unable to get buffer.");
22520 0 : return 0;
22521 : }
22522 : }
22523 0 : result = (bool)GDALMDArrayHS_Write__SWIG_5(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
22524 0 : jresult = (jboolean)result;
22525 : {
22526 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22527 0 : if (arg3) {
22528 0 : jenv->ReleaseLongArrayElements(jarg2, (jlong*)arg3, JNI_ABORT);
22529 : }
22530 : }
22531 : {
22532 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22533 0 : if (arg5) {
22534 0 : jenv->ReleaseLongArrayElements(jarg4, (jlong*)arg5, JNI_ABORT);
22535 : }
22536 : }
22537 : {
22538 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22539 0 : if (arg7) {
22540 0 : jenv->ReleaseLongArrayElements(jarg6, (jlong*)arg7, JNI_ABORT);
22541 : }
22542 : }
22543 : {
22544 : /* %typemap(freearg) (int nList, GInt64 *pList) */
22545 0 : if (arg9) {
22546 0 : jenv->ReleaseLongArrayElements(jarg8, (jlong*)arg9, JNI_ABORT);
22547 : }
22548 : }
22549 : {
22550 0 : jenv->ReleaseDoubleArrayElements(jarg10, (jdouble*) arg10, JNI_ABORT);
22551 : }
22552 0 : return jresult;
22553 : }
22554 :
22555 :
22556 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Attribute(JNIEnv *jenv, jclass jcls, jlong jarg1) {
22557 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22558 :
22559 : (void)jenv;
22560 : (void)jcls;
22561 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22562 0 : delete_GDALAttributeHS(arg1);
22563 0 : }
22564 :
22565 :
22566 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22567 0 : jstring jresult = 0 ;
22568 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22569 0 : char *result = 0 ;
22570 :
22571 : (void)jenv;
22572 : (void)jcls;
22573 : (void)jarg1_;
22574 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22575 0 : result = (char *)GDALAttributeHS_GetName(arg1);
22576 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22577 0 : return jresult;
22578 : }
22579 :
22580 :
22581 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetFullName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22582 0 : jstring jresult = 0 ;
22583 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22584 0 : char *result = 0 ;
22585 :
22586 : (void)jenv;
22587 : (void)jcls;
22588 : (void)jarg1_;
22589 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22590 0 : result = (char *)GDALAttributeHS_GetFullName(arg1);
22591 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22592 0 : return jresult;
22593 : }
22594 :
22595 :
22596 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetTotalElementsCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22597 0 : jlong jresult = 0 ;
22598 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22599 : GUIntBig result;
22600 :
22601 : (void)jenv;
22602 : (void)jcls;
22603 : (void)jarg1_;
22604 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22605 0 : result = GDALAttributeHS_GetTotalElementsCount(arg1);
22606 : {
22607 : /* %typemap(out) (GUIntBig) */
22608 0 : jresult = (jlong) result;
22609 : }
22610 0 : return jresult;
22611 : }
22612 :
22613 :
22614 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetDimensionCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22615 0 : jlong jresult = 0 ;
22616 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22617 : size_t result;
22618 :
22619 : (void)jenv;
22620 : (void)jcls;
22621 : (void)jarg1_;
22622 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22623 0 : result = GDALAttributeHS_GetDimensionCount(arg1);
22624 0 : jresult = (jlong)result;
22625 0 : return jresult;
22626 : }
22627 :
22628 :
22629 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetDataType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22630 0 : jlong jresult = 0 ;
22631 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22632 0 : GDALExtendedDataTypeHS *result = 0 ;
22633 :
22634 : (void)jenv;
22635 : (void)jcls;
22636 : (void)jarg1_;
22637 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22638 0 : result = (GDALExtendedDataTypeHS *)GDALAttributeHS_GetDataType(arg1);
22639 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
22640 0 : return jresult;
22641 : }
22642 :
22643 :
22644 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1ReadAsString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22645 0 : jstring jresult = 0 ;
22646 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22647 0 : char *result = 0 ;
22648 :
22649 : (void)jenv;
22650 : (void)jcls;
22651 : (void)jarg1_;
22652 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22653 0 : result = (char *)GDALAttributeHS_ReadAsString(arg1);
22654 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22655 0 : return jresult;
22656 : }
22657 :
22658 :
22659 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1ReadAsInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22660 0 : jint jresult = 0 ;
22661 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22662 : int result;
22663 :
22664 : (void)jenv;
22665 : (void)jcls;
22666 : (void)jarg1_;
22667 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22668 0 : result = (int)GDALAttributeHS_ReadAsInt(arg1);
22669 0 : jresult = (jint)result;
22670 0 : return jresult;
22671 : }
22672 :
22673 :
22674 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1ReadAsDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22675 0 : jdouble jresult = 0 ;
22676 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22677 : double result;
22678 :
22679 : (void)jenv;
22680 : (void)jcls;
22681 : (void)jarg1_;
22682 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22683 0 : result = (double)GDALAttributeHS_ReadAsDouble(arg1);
22684 0 : jresult = (jdouble)result;
22685 0 : return jresult;
22686 : }
22687 :
22688 :
22689 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1ReadAsStringArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22690 0 : jobject jresult = 0 ;
22691 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22692 0 : char **result = 0 ;
22693 :
22694 : (void)jenv;
22695 : (void)jcls;
22696 : (void)jarg1_;
22697 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22698 0 : result = (char **)GDALAttributeHS_ReadAsStringArray(arg1);
22699 : {
22700 : /* %typemap(out) char **CSL */
22701 0 : char **stringarray = result;
22702 0 : const jclass vector = jenv->FindClass("java/util/Vector");
22703 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
22704 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
22705 :
22706 0 : jresult = jenv->NewObject(vector, constructor);
22707 0 : if ( stringarray != NULL ) {
22708 0 : while(*stringarray != NULL) {
22709 : /*printf("working on string %s\n", *stringarray);*/
22710 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
22711 0 : jenv->CallBooleanMethod(jresult, add, value);
22712 0 : jenv->DeleteLocalRef(value);
22713 0 : stringarray++;
22714 : }
22715 : }
22716 0 : CSLDestroy(result);
22717 : }
22718 0 : return jresult;
22719 : }
22720 :
22721 :
22722 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1WriteString(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
22723 0 : jint jresult = 0 ;
22724 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22725 0 : char *arg2 = (char *) 0 ;
22726 : CPLErr result;
22727 :
22728 : (void)jenv;
22729 : (void)jcls;
22730 : (void)jarg1_;
22731 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22732 0 : arg2 = 0;
22733 0 : if (jarg2) {
22734 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
22735 0 : if (!arg2) return 0;
22736 : }
22737 0 : result = (CPLErr)GDALAttributeHS_WriteString(arg1,(char const *)arg2);
22738 0 : jresult = (jint)result;
22739 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
22740 0 : return jresult;
22741 : }
22742 :
22743 :
22744 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1WriteStringArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
22745 0 : jint jresult = 0 ;
22746 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22747 0 : char **arg2 = (char **) 0 ;
22748 : CPLErr result;
22749 :
22750 : (void)jenv;
22751 : (void)jcls;
22752 : (void)jarg1_;
22753 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22754 : {
22755 : /* %typemap(in) char **options */
22756 0 : arg2 = NULL;
22757 0 : if(jarg2 != 0) {
22758 0 : const jclass vector = jenv->FindClass("java/util/Vector");
22759 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
22760 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
22761 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
22762 : "()Ljava/util/Enumeration;");
22763 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
22764 : "hasMoreElements", "()Z");
22765 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
22766 : "nextElement", "()Ljava/lang/Object;");
22767 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
22768 0 : hasMoreElements == NULL || getNextElement == NULL) {
22769 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
22770 0 : return 0;
22771 : }
22772 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
22773 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
22774 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
22775 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
22776 : {
22777 0 : CSLDestroy(arg2);
22778 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
22779 0 : return 0;
22780 : }
22781 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
22782 0 : arg2 = CSLAddString(arg2, valptr);
22783 0 : jenv->ReleaseStringUTFChars(value, valptr);
22784 : }
22785 : }
22786 : }
22787 0 : result = (CPLErr)GDALAttributeHS_WriteStringArray(arg1,arg2);
22788 0 : jresult = (jint)result;
22789 : {
22790 : /* %typemap(freearg) char **options */
22791 0 : CSLDestroy( arg2 );
22792 : }
22793 0 : return jresult;
22794 : }
22795 :
22796 :
22797 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1WriteInt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
22798 0 : jint jresult = 0 ;
22799 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22800 : int arg2 ;
22801 : CPLErr result;
22802 :
22803 : (void)jenv;
22804 : (void)jcls;
22805 : (void)jarg1_;
22806 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22807 0 : arg2 = (int)jarg2;
22808 0 : result = (CPLErr)GDALAttributeHS_WriteInt(arg1,arg2);
22809 0 : jresult = (jint)result;
22810 0 : return jresult;
22811 : }
22812 :
22813 :
22814 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1WriteDouble(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
22815 0 : jint jresult = 0 ;
22816 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22817 : double arg2 ;
22818 : CPLErr result;
22819 :
22820 : (void)jenv;
22821 : (void)jcls;
22822 : (void)jarg1_;
22823 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22824 0 : arg2 = (double)jarg2;
22825 0 : result = (CPLErr)GDALAttributeHS_WriteDouble(arg1,arg2);
22826 0 : jresult = (jint)result;
22827 0 : return jresult;
22828 : }
22829 :
22830 :
22831 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1Rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
22832 0 : jint jresult = 0 ;
22833 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22834 0 : char *arg2 = (char *) 0 ;
22835 : CPLErr result;
22836 :
22837 : (void)jenv;
22838 : (void)jcls;
22839 : (void)jarg1_;
22840 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22841 0 : arg2 = 0;
22842 0 : if (jarg2) {
22843 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
22844 0 : if (!arg2) return 0;
22845 : }
22846 0 : result = (CPLErr)GDALAttributeHS_Rename(arg1,(char const *)arg2);
22847 0 : jresult = (jint)result;
22848 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
22849 0 : return jresult;
22850 : }
22851 :
22852 :
22853 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Attribute_1GetDimensionSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
22854 0 : jlong jresult = 0 ;
22855 0 : GDALAttributeHS *arg1 = (GDALAttributeHS *) 0 ;
22856 : size_t arg2 ;
22857 : size_t result;
22858 :
22859 : (void)jenv;
22860 : (void)jcls;
22861 : (void)jarg1_;
22862 0 : arg1 = *(GDALAttributeHS **)&jarg1;
22863 0 : arg2 = (size_t)jarg2;
22864 0 : result = GDALAttributeHS_GetDimensionSize(arg1,arg2);
22865 0 : jresult = (jlong)result;
22866 0 : return jresult;
22867 : }
22868 :
22869 :
22870 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Dimension(JNIEnv *jenv, jclass jcls, jlong jarg1) {
22871 0 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22872 :
22873 : (void)jenv;
22874 : (void)jcls;
22875 0 : arg1 = *(GDALDimensionHS **)&jarg1;
22876 0 : delete_GDALDimensionHS(arg1);
22877 0 : }
22878 :
22879 :
22880 10 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22881 10 : jstring jresult = 0 ;
22882 10 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22883 10 : char *result = 0 ;
22884 :
22885 : (void)jenv;
22886 : (void)jcls;
22887 : (void)jarg1_;
22888 10 : arg1 = *(GDALDimensionHS **)&jarg1;
22889 10 : result = (char *)GDALDimensionHS_GetName(arg1);
22890 10 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22891 10 : return jresult;
22892 : }
22893 :
22894 :
22895 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetFullName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22896 0 : jstring jresult = 0 ;
22897 0 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22898 0 : char *result = 0 ;
22899 :
22900 : (void)jenv;
22901 : (void)jcls;
22902 : (void)jarg1_;
22903 0 : arg1 = *(GDALDimensionHS **)&jarg1;
22904 0 : result = (char *)GDALDimensionHS_GetFullName(arg1);
22905 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22906 0 : return jresult;
22907 : }
22908 :
22909 :
22910 10 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22911 10 : jstring jresult = 0 ;
22912 10 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22913 10 : char *result = 0 ;
22914 :
22915 : (void)jenv;
22916 : (void)jcls;
22917 : (void)jarg1_;
22918 10 : arg1 = *(GDALDimensionHS **)&jarg1;
22919 10 : result = (char *)GDALDimensionHS_GetType(arg1);
22920 10 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22921 10 : return jresult;
22922 : }
22923 :
22924 :
22925 10 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetDirection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22926 10 : jstring jresult = 0 ;
22927 10 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22928 10 : char *result = 0 ;
22929 :
22930 : (void)jenv;
22931 : (void)jcls;
22932 : (void)jarg1_;
22933 10 : arg1 = *(GDALDimensionHS **)&jarg1;
22934 10 : result = (char *)GDALDimensionHS_GetDirection(arg1);
22935 10 : if (result) jresult = jenv->NewStringUTF((const char *)result);
22936 10 : return jresult;
22937 : }
22938 :
22939 :
22940 10 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22941 10 : jlong jresult = 0 ;
22942 10 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22943 : GUIntBig result;
22944 :
22945 : (void)jenv;
22946 : (void)jcls;
22947 : (void)jarg1_;
22948 10 : arg1 = *(GDALDimensionHS **)&jarg1;
22949 10 : result = GDALDimensionHS_GetSize(arg1);
22950 : {
22951 : /* %typemap(out) (GUIntBig) */
22952 10 : jresult = (jlong) result;
22953 : }
22954 10 : return jresult;
22955 : }
22956 :
22957 :
22958 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1GetIndexingVariable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
22959 0 : jlong jresult = 0 ;
22960 0 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22961 0 : GDALMDArrayHS *result = 0 ;
22962 :
22963 : (void)jenv;
22964 : (void)jcls;
22965 : (void)jarg1_;
22966 0 : arg1 = *(GDALDimensionHS **)&jarg1;
22967 0 : result = (GDALMDArrayHS *)GDALDimensionHS_GetIndexingVariable(arg1);
22968 0 : *(GDALMDArrayHS **)&jresult = result;
22969 0 : return jresult;
22970 : }
22971 :
22972 :
22973 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1SetIndexingVariable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
22974 0 : jboolean jresult = 0 ;
22975 0 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22976 0 : GDALMDArrayHS *arg2 = (GDALMDArrayHS *) 0 ;
22977 : bool result;
22978 :
22979 : (void)jenv;
22980 : (void)jcls;
22981 : (void)jarg1_;
22982 : (void)jarg2_;
22983 0 : arg1 = *(GDALDimensionHS **)&jarg1;
22984 0 : arg2 = *(GDALMDArrayHS **)&jarg2;
22985 0 : result = (bool)GDALDimensionHS_SetIndexingVariable(arg1,arg2);
22986 0 : jresult = (jboolean)result;
22987 0 : return jresult;
22988 : }
22989 :
22990 :
22991 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Dimension_1Rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
22992 0 : jint jresult = 0 ;
22993 0 : GDALDimensionHS *arg1 = (GDALDimensionHS *) 0 ;
22994 0 : char *arg2 = (char *) 0 ;
22995 : CPLErr result;
22996 :
22997 : (void)jenv;
22998 : (void)jcls;
22999 : (void)jarg1_;
23000 0 : arg1 = *(GDALDimensionHS **)&jarg1;
23001 0 : arg2 = 0;
23002 0 : if (jarg2) {
23003 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
23004 0 : if (!arg2) return 0;
23005 : }
23006 0 : result = (CPLErr)GDALDimensionHS_Rename(arg1,(char const *)arg2);
23007 0 : jresult = (jint)result;
23008 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
23009 0 : return jresult;
23010 : }
23011 :
23012 :
23013 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1ExtendedDataType(JNIEnv *jenv, jclass jcls, jlong jarg1) {
23014 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23015 :
23016 : (void)jenv;
23017 : (void)jcls;
23018 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23019 0 : delete_GDALExtendedDataTypeHS(arg1);
23020 0 : }
23021 :
23022 :
23023 4 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1Create(JNIEnv *jenv, jclass jcls, jint jarg1) {
23024 4 : jlong jresult = 0 ;
23025 : GDALDataType arg1 ;
23026 4 : GDALExtendedDataTypeHS *result = 0 ;
23027 :
23028 : (void)jenv;
23029 : (void)jcls;
23030 4 : arg1 = (GDALDataType)jarg1;
23031 4 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_Create(arg1);
23032 4 : *(GDALExtendedDataTypeHS **)&jresult = result;
23033 4 : return jresult;
23034 : }
23035 :
23036 :
23037 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1CreateString_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2) {
23038 0 : jlong jresult = 0 ;
23039 : size_t arg1 ;
23040 : GDALExtendedDataTypeSubType arg2 ;
23041 0 : GDALExtendedDataTypeHS *result = 0 ;
23042 :
23043 : (void)jenv;
23044 : (void)jcls;
23045 0 : arg1 = (size_t)jarg1;
23046 0 : arg2 = (GDALExtendedDataTypeSubType)jarg2;
23047 0 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_CreateString__SWIG_0(arg1,arg2);
23048 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
23049 0 : return jresult;
23050 : }
23051 :
23052 :
23053 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1CreateString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
23054 0 : jlong jresult = 0 ;
23055 : size_t arg1 ;
23056 0 : GDALExtendedDataTypeHS *result = 0 ;
23057 :
23058 : (void)jenv;
23059 : (void)jcls;
23060 0 : arg1 = (size_t)jarg1;
23061 0 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_CreateString__SWIG_0(arg1);
23062 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
23063 0 : return jresult;
23064 : }
23065 :
23066 :
23067 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1CreateString_1_1SWIG_12(JNIEnv *jenv, jclass jcls) {
23068 0 : jlong jresult = 0 ;
23069 0 : GDALExtendedDataTypeHS *result = 0 ;
23070 :
23071 : (void)jenv;
23072 : (void)jcls;
23073 0 : result = (GDALExtendedDataTypeHS *)GDALExtendedDataTypeHS_CreateString__SWIG_0();
23074 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
23075 0 : return jresult;
23076 : }
23077 :
23078 :
23079 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23080 0 : jstring jresult = 0 ;
23081 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23082 0 : char *result = 0 ;
23083 :
23084 : (void)jenv;
23085 : (void)jcls;
23086 : (void)jarg1_;
23087 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23088 0 : result = (char *)GDALExtendedDataTypeHS_GetName(arg1);
23089 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
23090 0 : return jresult;
23091 : }
23092 :
23093 :
23094 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetClass(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23095 0 : jint jresult = 0 ;
23096 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23097 : GDALExtendedDataTypeClass result;
23098 :
23099 : (void)jenv;
23100 : (void)jcls;
23101 : (void)jarg1_;
23102 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23103 0 : result = (GDALExtendedDataTypeClass)GDALExtendedDataTypeHS_GetClass(arg1);
23104 0 : jresult = (jint)result;
23105 0 : return jresult;
23106 : }
23107 :
23108 :
23109 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetNumericDataType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23110 0 : jint jresult = 0 ;
23111 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23112 : GDALDataType result;
23113 :
23114 : (void)jenv;
23115 : (void)jcls;
23116 : (void)jarg1_;
23117 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23118 0 : result = (GDALDataType)GDALExtendedDataTypeHS_GetNumericDataType(arg1);
23119 0 : jresult = (jint)result;
23120 0 : return jresult;
23121 : }
23122 :
23123 :
23124 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23125 0 : jlong jresult = 0 ;
23126 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23127 : size_t result;
23128 :
23129 : (void)jenv;
23130 : (void)jcls;
23131 : (void)jarg1_;
23132 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23133 0 : result = GDALExtendedDataTypeHS_GetSize(arg1);
23134 0 : jresult = (jlong)result;
23135 0 : return jresult;
23136 : }
23137 :
23138 :
23139 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetMaxStringLength(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23140 0 : jlong jresult = 0 ;
23141 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23142 : size_t result;
23143 :
23144 : (void)jenv;
23145 : (void)jcls;
23146 : (void)jarg1_;
23147 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23148 0 : result = GDALExtendedDataTypeHS_GetMaxStringLength(arg1);
23149 0 : jresult = (jlong)result;
23150 0 : return jresult;
23151 : }
23152 :
23153 :
23154 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1GetSubType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23155 0 : jint jresult = 0 ;
23156 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23157 : GDALExtendedDataTypeSubType result;
23158 :
23159 : (void)jenv;
23160 : (void)jcls;
23161 : (void)jarg1_;
23162 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23163 0 : result = (GDALExtendedDataTypeSubType)GDALExtendedDataTypeHS_GetSubType(arg1);
23164 0 : jresult = (jint)result;
23165 0 : return jresult;
23166 : }
23167 :
23168 :
23169 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1CanConvertTo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
23170 0 : jboolean jresult = 0 ;
23171 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23172 0 : GDALExtendedDataTypeHS *arg2 = (GDALExtendedDataTypeHS *) 0 ;
23173 : bool result;
23174 :
23175 : (void)jenv;
23176 : (void)jcls;
23177 : (void)jarg1_;
23178 : (void)jarg2_;
23179 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23180 0 : arg2 = *(GDALExtendedDataTypeHS **)&jarg2;
23181 : {
23182 0 : if (!arg2) {
23183 : {
23184 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
23185 : };
23186 : }
23187 : }
23188 0 : result = (bool)GDALExtendedDataTypeHS_CanConvertTo(arg1,arg2);
23189 0 : jresult = (jboolean)result;
23190 0 : return jresult;
23191 : }
23192 :
23193 :
23194 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_ExtendedDataType_1Equals(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
23195 0 : jboolean jresult = 0 ;
23196 0 : GDALExtendedDataTypeHS *arg1 = (GDALExtendedDataTypeHS *) 0 ;
23197 0 : GDALExtendedDataTypeHS *arg2 = (GDALExtendedDataTypeHS *) 0 ;
23198 : bool result;
23199 :
23200 : (void)jenv;
23201 : (void)jcls;
23202 : (void)jarg1_;
23203 : (void)jarg2_;
23204 0 : arg1 = *(GDALExtendedDataTypeHS **)&jarg1;
23205 0 : arg2 = *(GDALExtendedDataTypeHS **)&jarg2;
23206 : {
23207 0 : if (!arg2) {
23208 : {
23209 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
23210 : };
23211 : }
23212 : }
23213 0 : result = (bool)GDALExtendedDataTypeHS_Equals(arg1,arg2);
23214 0 : jresult = (jboolean)result;
23215 0 : return jresult;
23216 : }
23217 :
23218 :
23219 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1EDTComponent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
23220 0 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
23221 :
23222 : (void)jenv;
23223 : (void)jcls;
23224 0 : arg1 = *(GDALEDTComponentHS **)&jarg1;
23225 0 : delete_GDALEDTComponentHS(arg1);
23226 0 : }
23227 :
23228 :
23229 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_EDTComponent_1Create(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jlong jarg3, jobject jarg3_) {
23230 0 : jlong jresult = 0 ;
23231 0 : char *arg1 = (char *) 0 ;
23232 : size_t arg2 ;
23233 0 : GDALExtendedDataTypeHS *arg3 = (GDALExtendedDataTypeHS *) 0 ;
23234 0 : GDALEDTComponentHS *result = 0 ;
23235 :
23236 : (void)jenv;
23237 : (void)jcls;
23238 : (void)jarg3_;
23239 0 : arg1 = 0;
23240 0 : if (jarg1) {
23241 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
23242 0 : if (!arg1) return 0;
23243 : }
23244 0 : arg2 = (size_t)jarg2;
23245 0 : arg3 = *(GDALExtendedDataTypeHS **)&jarg3;
23246 : {
23247 0 : if (!arg1) {
23248 : {
23249 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
23250 : };
23251 : }
23252 : }
23253 : {
23254 0 : if (!arg3) {
23255 : {
23256 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
23257 : };
23258 : }
23259 : }
23260 0 : result = (GDALEDTComponentHS *)GDALEDTComponentHS_Create((char const *)arg1,arg2,arg3);
23261 0 : *(GDALEDTComponentHS **)&jresult = result;
23262 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
23263 0 : return jresult;
23264 : }
23265 :
23266 :
23267 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_EDTComponent_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23268 0 : jstring jresult = 0 ;
23269 0 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
23270 0 : char *result = 0 ;
23271 :
23272 : (void)jenv;
23273 : (void)jcls;
23274 : (void)jarg1_;
23275 0 : arg1 = *(GDALEDTComponentHS **)&jarg1;
23276 0 : result = (char *)GDALEDTComponentHS_GetName(arg1);
23277 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
23278 0 : return jresult;
23279 : }
23280 :
23281 :
23282 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_EDTComponent_1GetOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23283 0 : jlong jresult = 0 ;
23284 0 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
23285 : size_t result;
23286 :
23287 : (void)jenv;
23288 : (void)jcls;
23289 : (void)jarg1_;
23290 0 : arg1 = *(GDALEDTComponentHS **)&jarg1;
23291 0 : result = GDALEDTComponentHS_GetOffset(arg1);
23292 0 : jresult = (jlong)result;
23293 0 : return jresult;
23294 : }
23295 :
23296 :
23297 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_EDTComponent_1GetType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23298 0 : jlong jresult = 0 ;
23299 0 : GDALEDTComponentHS *arg1 = (GDALEDTComponentHS *) 0 ;
23300 0 : GDALExtendedDataTypeHS *result = 0 ;
23301 :
23302 : (void)jenv;
23303 : (void)jcls;
23304 : (void)jarg1_;
23305 0 : arg1 = *(GDALEDTComponentHS **)&jarg1;
23306 0 : result = (GDALExtendedDataTypeHS *)GDALEDTComponentHS_GetType(arg1);
23307 0 : *(GDALExtendedDataTypeHS **)&jresult = result;
23308 0 : return jresult;
23309 : }
23310 :
23311 :
23312 8 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1XSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23313 8 : jint jresult = 0 ;
23314 8 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23315 : int result;
23316 :
23317 : (void)jenv;
23318 : (void)jcls;
23319 : (void)jarg1_;
23320 8 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23321 8 : result = (int)GDALRasterBandShadow_XSize_get(arg1);
23322 8 : jresult = (jint)result;
23323 8 : return jresult;
23324 : }
23325 :
23326 :
23327 8 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1YSize_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23328 8 : jint jresult = 0 ;
23329 8 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23330 : int result;
23331 :
23332 : (void)jenv;
23333 : (void)jcls;
23334 : (void)jarg1_;
23335 8 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23336 8 : result = (int)GDALRasterBandShadow_YSize_get(arg1);
23337 8 : jresult = (jint)result;
23338 8 : return jresult;
23339 : }
23340 :
23341 :
23342 4 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1DataType_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23343 4 : jint jresult = 0 ;
23344 4 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23345 : GDALDataType result;
23346 :
23347 : (void)jenv;
23348 : (void)jcls;
23349 : (void)jarg1_;
23350 4 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23351 4 : result = (GDALDataType)GDALRasterBandShadow_DataType_get(arg1);
23352 4 : jresult = (jint)result;
23353 4 : return jresult;
23354 : }
23355 :
23356 :
23357 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetDataset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23358 0 : jlong jresult = 0 ;
23359 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23360 0 : GDALDatasetShadow *result = 0 ;
23361 :
23362 : (void)jenv;
23363 : (void)jcls;
23364 : (void)jarg1_;
23365 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23366 0 : result = (GDALDatasetShadow *)GDALRasterBandShadow_GetDataset(arg1);
23367 0 : *(GDALDatasetShadow **)&jresult = result;
23368 0 : return jresult;
23369 : }
23370 :
23371 :
23372 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23373 0 : jint jresult = 0 ;
23374 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23375 : int result;
23376 :
23377 : (void)jenv;
23378 : (void)jcls;
23379 : (void)jarg1_;
23380 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23381 0 : result = (int)GDALRasterBandShadow_GetBand(arg1);
23382 0 : jresult = (jint)result;
23383 0 : return jresult;
23384 : }
23385 :
23386 :
23387 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetBlockSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2, jintArray jarg3) {
23388 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23389 1 : int *arg2 = (int *) 0 ;
23390 1 : int *arg3 = (int *) 0 ;
23391 : int temp2 ;
23392 : int temp3 ;
23393 :
23394 : (void)jenv;
23395 : (void)jcls;
23396 : (void)jarg1_;
23397 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23398 : {
23399 1 : if (!jarg2) {
23400 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23401 0 : return ;
23402 : }
23403 1 : if (jenv->GetArrayLength(jarg2) == 0) {
23404 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23405 0 : return ;
23406 : }
23407 1 : temp2 = (int)0;
23408 1 : arg2 = &temp2;
23409 : }
23410 : {
23411 1 : if (!jarg3) {
23412 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23413 0 : return ;
23414 : }
23415 1 : if (jenv->GetArrayLength(jarg3) == 0) {
23416 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23417 0 : return ;
23418 : }
23419 1 : temp3 = (int)0;
23420 1 : arg3 = &temp3;
23421 : }
23422 1 : GDALRasterBandShadow_GetBlockSize(arg1,arg2,arg3);
23423 : {
23424 1 : jint jvalue = (jint)temp2;
23425 1 : jenv->SetIntArrayRegion(jarg2, 0, 1, &jvalue);
23426 : }
23427 : {
23428 1 : jint jvalue = (jint)temp3;
23429 1 : jenv->SetIntArrayRegion(jarg3, 0, 1, &jvalue);
23430 : }
23431 :
23432 :
23433 : }
23434 :
23435 :
23436 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetColorInterpretation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23437 0 : jint jresult = 0 ;
23438 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23439 : GDALColorInterp result;
23440 :
23441 : (void)jenv;
23442 : (void)jcls;
23443 : (void)jarg1_;
23444 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23445 0 : result = (GDALColorInterp)GDALRasterBandShadow_GetColorInterpretation(arg1);
23446 0 : jresult = (jint)result;
23447 0 : return jresult;
23448 : }
23449 :
23450 :
23451 5 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetRasterColorInterpretation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23452 5 : jint jresult = 0 ;
23453 5 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23454 : GDALColorInterp result;
23455 :
23456 : (void)jenv;
23457 : (void)jcls;
23458 : (void)jarg1_;
23459 5 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23460 5 : result = (GDALColorInterp)GDALRasterBandShadow_GetRasterColorInterpretation(arg1);
23461 5 : jresult = (jint)result;
23462 5 : return jresult;
23463 : }
23464 :
23465 :
23466 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetColorInterpretation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
23467 0 : jint jresult = 0 ;
23468 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23469 : GDALColorInterp arg2 ;
23470 : CPLErr result;
23471 :
23472 : (void)jenv;
23473 : (void)jcls;
23474 : (void)jarg1_;
23475 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23476 0 : arg2 = (GDALColorInterp)jarg2;
23477 0 : result = (CPLErr)GDALRasterBandShadow_SetColorInterpretation(arg1,arg2);
23478 0 : jresult = (jint)result;
23479 0 : return jresult;
23480 : }
23481 :
23482 :
23483 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetRasterColorInterpretation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
23484 0 : jint jresult = 0 ;
23485 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23486 : GDALColorInterp arg2 ;
23487 : CPLErr result;
23488 :
23489 : (void)jenv;
23490 : (void)jcls;
23491 : (void)jarg1_;
23492 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23493 0 : arg2 = (GDALColorInterp)jarg2;
23494 0 : result = (CPLErr)GDALRasterBandShadow_SetRasterColorInterpretation(arg1,arg2);
23495 0 : jresult = (jint)result;
23496 0 : return jresult;
23497 : }
23498 :
23499 :
23500 2 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetNoDataValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
23501 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23502 2 : double *arg2 = (double *) 0 ;
23503 2 : int *arg3 = (int *) 0 ;
23504 : double tmpval2 ;
23505 : int tmphasval2 ;
23506 :
23507 : (void)jenv;
23508 : (void)jcls;
23509 : (void)jarg1_;
23510 2 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23511 : {
23512 : /* %typemap(in) (double *val, int*hasval) */
23513 2 : arg2 = &tmpval2;
23514 2 : arg3 = &tmphasval2;
23515 2 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
23516 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
23517 0 : return ;
23518 : }
23519 : }
23520 2 : GDALRasterBandShadow_GetNoDataValue(arg1,arg2,arg3);
23521 : {
23522 : /* %typemap(argout) (double *val, int*hasval) */
23523 2 : const jclass Double = jenv->FindClass("java/lang/Double");
23524 2 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
23525 : "(D)V");
23526 2 : if(*arg3) {
23527 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
23528 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
23529 : } else {
23530 2 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
23531 : }
23532 : }
23533 : }
23534 :
23535 :
23536 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetNoDataValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
23537 0 : jint jresult = 0 ;
23538 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23539 : double arg2 ;
23540 : CPLErr result;
23541 :
23542 : (void)jenv;
23543 : (void)jcls;
23544 : (void)jarg1_;
23545 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23546 0 : arg2 = (double)jarg2;
23547 0 : result = (CPLErr)GDALRasterBandShadow_SetNoDataValue(arg1,arg2);
23548 0 : jresult = (jint)result;
23549 0 : return jresult;
23550 : }
23551 :
23552 :
23553 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1DeleteNoDataValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23554 0 : jint jresult = 0 ;
23555 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23556 : CPLErr result;
23557 :
23558 : (void)jenv;
23559 : (void)jcls;
23560 : (void)jarg1_;
23561 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23562 0 : result = (CPLErr)GDALRasterBandShadow_DeleteNoDataValue(arg1);
23563 0 : jresult = (jint)result;
23564 0 : return jresult;
23565 : }
23566 :
23567 :
23568 2 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetUnitType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23569 2 : jstring jresult = 0 ;
23570 2 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23571 2 : char *result = 0 ;
23572 :
23573 : (void)jenv;
23574 : (void)jcls;
23575 : (void)jarg1_;
23576 2 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23577 2 : result = (char *)GDALRasterBandShadow_GetUnitType(arg1);
23578 2 : if (result) jresult = jenv->NewStringUTF((const char *)result);
23579 2 : return jresult;
23580 : }
23581 :
23582 :
23583 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetUnitType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
23584 0 : jint jresult = 0 ;
23585 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23586 0 : char *arg2 = (char *) 0 ;
23587 : CPLErr result;
23588 :
23589 : (void)jenv;
23590 : (void)jcls;
23591 : (void)jarg1_;
23592 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23593 0 : arg2 = 0;
23594 0 : if (jarg2) {
23595 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
23596 0 : if (!arg2) return 0;
23597 : }
23598 0 : result = (CPLErr)GDALRasterBandShadow_SetUnitType(arg1,(char const *)arg2);
23599 0 : jresult = (jint)result;
23600 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
23601 0 : return jresult;
23602 : }
23603 :
23604 :
23605 1 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetRasterCategoryNames(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
23606 1 : jobject jresult = 0 ;
23607 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23608 1 : char **result = 0 ;
23609 :
23610 : (void)jenv;
23611 : (void)jcls;
23612 : (void)jarg1_;
23613 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23614 1 : result = (char **)GDALRasterBandShadow_GetRasterCategoryNames(arg1);
23615 : {
23616 : /* %typemap(out) char **options */
23617 1 : char **stringarray = result;
23618 1 : const jclass vector = jenv->FindClass("java/util/Vector");
23619 1 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
23620 1 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
23621 :
23622 1 : jresult = jenv->NewObject(vector, constructor);
23623 1 : if ( stringarray != NULL ) {
23624 0 : while(*stringarray != NULL) {
23625 : /*printf("working on string %s\n", *stringarray);*/
23626 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
23627 0 : jenv->CallBooleanMethod(jresult, add, value);
23628 0 : jenv->DeleteLocalRef(value);
23629 0 : stringarray++;
23630 : }
23631 : }
23632 : }
23633 1 : return jresult;
23634 : }
23635 :
23636 :
23637 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetRasterCategoryNames(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
23638 0 : jint jresult = 0 ;
23639 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23640 0 : char **arg2 = (char **) 0 ;
23641 : CPLErr result;
23642 :
23643 : (void)jenv;
23644 : (void)jcls;
23645 : (void)jarg1_;
23646 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23647 : {
23648 : /* %typemap(in) char **options */
23649 0 : arg2 = NULL;
23650 0 : if(jarg2 != 0) {
23651 0 : const jclass vector = jenv->FindClass("java/util/Vector");
23652 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
23653 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
23654 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
23655 : "()Ljava/util/Enumeration;");
23656 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
23657 : "hasMoreElements", "()Z");
23658 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
23659 : "nextElement", "()Ljava/lang/Object;");
23660 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
23661 0 : hasMoreElements == NULL || getNextElement == NULL) {
23662 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
23663 0 : return 0;
23664 : }
23665 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
23666 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
23667 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
23668 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
23669 : {
23670 0 : CSLDestroy(arg2);
23671 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
23672 0 : return 0;
23673 : }
23674 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
23675 0 : arg2 = CSLAddString(arg2, valptr);
23676 0 : jenv->ReleaseStringUTFChars(value, valptr);
23677 : }
23678 : }
23679 : }
23680 0 : result = (CPLErr)GDALRasterBandShadow_SetRasterCategoryNames(arg1,arg2);
23681 0 : jresult = (jint)result;
23682 : {
23683 : /* %typemap(freearg) char **options */
23684 0 : CSLDestroy( arg2 );
23685 : }
23686 0 : return jresult;
23687 : }
23688 :
23689 :
23690 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetMinimum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
23691 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23692 1 : double *arg2 = (double *) 0 ;
23693 1 : int *arg3 = (int *) 0 ;
23694 : double tmpval2 ;
23695 : int tmphasval2 ;
23696 :
23697 : (void)jenv;
23698 : (void)jcls;
23699 : (void)jarg1_;
23700 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23701 : {
23702 : /* %typemap(in) (double *val, int*hasval) */
23703 1 : arg2 = &tmpval2;
23704 1 : arg3 = &tmphasval2;
23705 1 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
23706 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
23707 0 : return ;
23708 : }
23709 : }
23710 1 : GDALRasterBandShadow_GetMinimum(arg1,arg2,arg3);
23711 : {
23712 : /* %typemap(argout) (double *val, int*hasval) */
23713 1 : const jclass Double = jenv->FindClass("java/lang/Double");
23714 1 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
23715 : "(D)V");
23716 1 : if(*arg3) {
23717 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
23718 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
23719 : } else {
23720 1 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
23721 : }
23722 : }
23723 : }
23724 :
23725 :
23726 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetMaximum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
23727 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23728 1 : double *arg2 = (double *) 0 ;
23729 1 : int *arg3 = (int *) 0 ;
23730 : double tmpval2 ;
23731 : int tmphasval2 ;
23732 :
23733 : (void)jenv;
23734 : (void)jcls;
23735 : (void)jarg1_;
23736 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23737 : {
23738 : /* %typemap(in) (double *val, int*hasval) */
23739 1 : arg2 = &tmpval2;
23740 1 : arg3 = &tmphasval2;
23741 1 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
23742 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
23743 0 : return ;
23744 : }
23745 : }
23746 1 : GDALRasterBandShadow_GetMaximum(arg1,arg2,arg3);
23747 : {
23748 : /* %typemap(argout) (double *val, int*hasval) */
23749 1 : const jclass Double = jenv->FindClass("java/lang/Double");
23750 1 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
23751 : "(D)V");
23752 1 : if(*arg3) {
23753 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
23754 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
23755 : } else {
23756 1 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
23757 : }
23758 : }
23759 : }
23760 :
23761 :
23762 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
23763 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23764 1 : double *arg2 = (double *) 0 ;
23765 1 : int *arg3 = (int *) 0 ;
23766 : double tmpval2 ;
23767 : int tmphasval2 ;
23768 :
23769 : (void)jenv;
23770 : (void)jcls;
23771 : (void)jarg1_;
23772 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23773 : {
23774 : /* %typemap(in) (double *val, int*hasval) */
23775 1 : arg2 = &tmpval2;
23776 1 : arg3 = &tmphasval2;
23777 1 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
23778 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
23779 0 : return ;
23780 : }
23781 : }
23782 1 : GDALRasterBandShadow_GetOffset(arg1,arg2,arg3);
23783 : {
23784 : /* %typemap(argout) (double *val, int*hasval) */
23785 1 : const jclass Double = jenv->FindClass("java/lang/Double");
23786 1 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
23787 : "(D)V");
23788 1 : if(*arg3) {
23789 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
23790 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
23791 : } else {
23792 1 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
23793 : }
23794 : }
23795 : }
23796 :
23797 :
23798 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetScale(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
23799 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23800 1 : double *arg2 = (double *) 0 ;
23801 1 : int *arg3 = (int *) 0 ;
23802 : double tmpval2 ;
23803 : int tmphasval2 ;
23804 :
23805 : (void)jenv;
23806 : (void)jcls;
23807 : (void)jarg1_;
23808 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23809 : {
23810 : /* %typemap(in) (double *val, int*hasval) */
23811 1 : arg2 = &tmpval2;
23812 1 : arg3 = &tmphasval2;
23813 1 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) < 1) {
23814 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array or empty array");
23815 0 : return ;
23816 : }
23817 : }
23818 1 : GDALRasterBandShadow_GetScale(arg1,arg2,arg3);
23819 : {
23820 : /* %typemap(argout) (double *val, int*hasval) */
23821 1 : const jclass Double = jenv->FindClass("java/lang/Double");
23822 1 : const jmethodID ctor = jenv->GetMethodID(Double, "<init>",
23823 : "(D)V");
23824 1 : if(*arg3) {
23825 0 : jobject dbl = jenv->NewObject(Double, ctor, tmpval2);
23826 0 : jenv->SetObjectArrayElement(jarg2, (jsize)0, dbl);
23827 : } else {
23828 1 : jenv->SetObjectArrayElement(jarg2, (jsize)0, 0);
23829 : }
23830 : }
23831 : }
23832 :
23833 :
23834 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetOffset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
23835 0 : jint jresult = 0 ;
23836 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23837 : double arg2 ;
23838 : CPLErr result;
23839 :
23840 : (void)jenv;
23841 : (void)jcls;
23842 : (void)jarg1_;
23843 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23844 0 : arg2 = (double)jarg2;
23845 0 : result = (CPLErr)GDALRasterBandShadow_SetOffset(arg1,arg2);
23846 0 : jresult = (jint)result;
23847 0 : return jresult;
23848 : }
23849 :
23850 :
23851 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetScale(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
23852 0 : jint jresult = 0 ;
23853 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23854 : double arg2 ;
23855 : CPLErr result;
23856 :
23857 : (void)jenv;
23858 : (void)jcls;
23859 : (void)jarg1_;
23860 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23861 0 : arg2 = (double)jarg2;
23862 0 : result = (CPLErr)GDALRasterBandShadow_SetScale(arg1,arg2);
23863 0 : jresult = (jint)result;
23864 0 : return jresult;
23865 : }
23866 :
23867 :
23868 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jdoubleArray jarg7) {
23869 1 : jint jresult = 0 ;
23870 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23871 : int arg2 ;
23872 : int arg3 ;
23873 1 : double *arg4 = (double *) 0 ;
23874 1 : double *arg5 = (double *) 0 ;
23875 1 : double *arg6 = (double *) 0 ;
23876 1 : double *arg7 = (double *) 0 ;
23877 : double temp4 ;
23878 : double temp5 ;
23879 : double temp6 ;
23880 : double temp7 ;
23881 : CPLErr result;
23882 :
23883 : (void)jenv;
23884 : (void)jcls;
23885 : (void)jarg1_;
23886 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23887 1 : arg2 = (int)jarg2;
23888 1 : arg3 = (int)jarg3;
23889 : {
23890 1 : if (!jarg4) {
23891 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23892 0 : return 0;
23893 : }
23894 1 : if (jenv->GetArrayLength(jarg4) == 0) {
23895 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23896 0 : return 0;
23897 : }
23898 1 : temp4 = (double)0;
23899 1 : arg4 = &temp4;
23900 : }
23901 : {
23902 1 : if (!jarg5) {
23903 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23904 0 : return 0;
23905 : }
23906 1 : if (jenv->GetArrayLength(jarg5) == 0) {
23907 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23908 0 : return 0;
23909 : }
23910 1 : temp5 = (double)0;
23911 1 : arg5 = &temp5;
23912 : }
23913 : {
23914 1 : if (!jarg6) {
23915 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23916 0 : return 0;
23917 : }
23918 1 : if (jenv->GetArrayLength(jarg6) == 0) {
23919 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23920 0 : return 0;
23921 : }
23922 1 : temp6 = (double)0;
23923 1 : arg6 = &temp6;
23924 : }
23925 : {
23926 1 : if (!jarg7) {
23927 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23928 0 : return 0;
23929 : }
23930 1 : if (jenv->GetArrayLength(jarg7) == 0) {
23931 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23932 0 : return 0;
23933 : }
23934 1 : temp7 = (double)0;
23935 1 : arg7 = &temp7;
23936 : }
23937 1 : result = (CPLErr)GDALRasterBandShadow_GetStatistics(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
23938 1 : jresult = (jint)result;
23939 : {
23940 1 : jdouble jvalue = (jdouble)temp4;
23941 1 : jenv->SetDoubleArrayRegion(jarg4, 0, 1, &jvalue);
23942 : }
23943 : {
23944 1 : jdouble jvalue = (jdouble)temp5;
23945 1 : jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
23946 : }
23947 : {
23948 1 : jdouble jvalue = (jdouble)temp6;
23949 1 : jenv->SetDoubleArrayRegion(jarg6, 0, 1, &jvalue);
23950 : }
23951 : {
23952 1 : jdouble jvalue = (jdouble)temp7;
23953 1 : jenv->SetDoubleArrayRegion(jarg7, 0, 1, &jvalue);
23954 : }
23955 :
23956 :
23957 :
23958 :
23959 1 : return jresult;
23960 : }
23961 :
23962 :
23963 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeStatistics_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jdoubleArray jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jobject jarg7) {
23964 0 : jint jresult = 0 ;
23965 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
23966 : bool arg2 ;
23967 0 : double *arg3 = (double *) 0 ;
23968 0 : double *arg4 = (double *) 0 ;
23969 0 : double *arg5 = (double *) 0 ;
23970 0 : double *arg6 = (double *) 0 ;
23971 : GDALProgressFunc arg7 ;
23972 0 : void *arg8 = (void *) 0 ;
23973 : double temp3 ;
23974 : double temp4 ;
23975 : double temp5 ;
23976 : double temp6 ;
23977 : CPLErr result;
23978 :
23979 : (void)jenv;
23980 : (void)jcls;
23981 : JavaProgressData sProgressInfo;
23982 0 : sProgressInfo.jenv = jenv;
23983 0 : sProgressInfo.pJavaCallback = NULL;
23984 : (void)jarg1_;
23985 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
23986 0 : arg2 = jarg2 ? true : false;
23987 : {
23988 0 : if (!jarg3) {
23989 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
23990 0 : return 0;
23991 : }
23992 0 : if (jenv->GetArrayLength(jarg3) == 0) {
23993 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
23994 0 : return 0;
23995 : }
23996 0 : temp3 = (double)0;
23997 0 : arg3 = &temp3;
23998 : }
23999 : {
24000 0 : if (!jarg4) {
24001 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24002 0 : return 0;
24003 : }
24004 0 : if (jenv->GetArrayLength(jarg4) == 0) {
24005 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24006 0 : return 0;
24007 : }
24008 0 : temp4 = (double)0;
24009 0 : arg4 = &temp4;
24010 : }
24011 : {
24012 0 : if (!jarg5) {
24013 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24014 0 : return 0;
24015 : }
24016 0 : if (jenv->GetArrayLength(jarg5) == 0) {
24017 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24018 0 : return 0;
24019 : }
24020 0 : temp5 = (double)0;
24021 0 : arg5 = &temp5;
24022 : }
24023 : {
24024 0 : if (!jarg6) {
24025 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24026 0 : return 0;
24027 : }
24028 0 : if (jenv->GetArrayLength(jarg6) == 0) {
24029 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24030 0 : return 0;
24031 : }
24032 0 : temp6 = (double)0;
24033 0 : arg6 = &temp6;
24034 : }
24035 : {
24036 0 : if ( jarg7 != 0 ) {
24037 0 : sProgressInfo.pJavaCallback = jarg7;
24038 0 : arg7 = JavaProgressProxy;
24039 0 : arg8 = &sProgressInfo;
24040 : }
24041 : else
24042 : {
24043 0 : arg7 = NULL;
24044 0 : arg8 = NULL;
24045 : }
24046 : }
24047 0 : result = (CPLErr)GDALRasterBandShadow_ComputeStatistics__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24048 0 : jresult = (jint)result;
24049 : {
24050 0 : jdouble jvalue = (jdouble)temp3;
24051 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
24052 : }
24053 : {
24054 0 : jdouble jvalue = (jdouble)temp4;
24055 0 : jenv->SetDoubleArrayRegion(jarg4, 0, 1, &jvalue);
24056 : }
24057 : {
24058 0 : jdouble jvalue = (jdouble)temp5;
24059 0 : jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
24060 : }
24061 : {
24062 0 : jdouble jvalue = (jdouble)temp6;
24063 0 : jenv->SetDoubleArrayRegion(jarg6, 0, 1, &jvalue);
24064 : }
24065 :
24066 :
24067 :
24068 :
24069 0 : return jresult;
24070 : }
24071 :
24072 :
24073 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeStatistics_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jdoubleArray jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {
24074 0 : jint jresult = 0 ;
24075 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24076 : bool arg2 ;
24077 0 : double *arg3 = (double *) 0 ;
24078 0 : double *arg4 = (double *) 0 ;
24079 0 : double *arg5 = (double *) 0 ;
24080 0 : double *arg6 = (double *) 0 ;
24081 : double temp3 ;
24082 : double temp4 ;
24083 : double temp5 ;
24084 : double temp6 ;
24085 : CPLErr result;
24086 :
24087 : (void)jenv;
24088 : (void)jcls;
24089 : (void)jarg1_;
24090 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24091 0 : arg2 = jarg2 ? true : false;
24092 : {
24093 0 : if (!jarg3) {
24094 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24095 0 : return 0;
24096 : }
24097 0 : if (jenv->GetArrayLength(jarg3) == 0) {
24098 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24099 0 : return 0;
24100 : }
24101 0 : temp3 = (double)0;
24102 0 : arg3 = &temp3;
24103 : }
24104 : {
24105 0 : if (!jarg4) {
24106 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24107 0 : return 0;
24108 : }
24109 0 : if (jenv->GetArrayLength(jarg4) == 0) {
24110 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24111 0 : return 0;
24112 : }
24113 0 : temp4 = (double)0;
24114 0 : arg4 = &temp4;
24115 : }
24116 : {
24117 0 : if (!jarg5) {
24118 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24119 0 : return 0;
24120 : }
24121 0 : if (jenv->GetArrayLength(jarg5) == 0) {
24122 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24123 0 : return 0;
24124 : }
24125 0 : temp5 = (double)0;
24126 0 : arg5 = &temp5;
24127 : }
24128 : {
24129 0 : if (!jarg6) {
24130 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
24131 0 : return 0;
24132 : }
24133 0 : if (jenv->GetArrayLength(jarg6) == 0) {
24134 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
24135 0 : return 0;
24136 : }
24137 0 : temp6 = (double)0;
24138 0 : arg6 = &temp6;
24139 : }
24140 0 : result = (CPLErr)GDALRasterBandShadow_ComputeStatistics__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
24141 0 : jresult = (jint)result;
24142 : {
24143 0 : jdouble jvalue = (jdouble)temp3;
24144 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
24145 : }
24146 : {
24147 0 : jdouble jvalue = (jdouble)temp4;
24148 0 : jenv->SetDoubleArrayRegion(jarg4, 0, 1, &jvalue);
24149 : }
24150 : {
24151 0 : jdouble jvalue = (jdouble)temp5;
24152 0 : jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
24153 : }
24154 : {
24155 0 : jdouble jvalue = (jdouble)temp6;
24156 0 : jenv->SetDoubleArrayRegion(jarg6, 0, 1, &jvalue);
24157 : }
24158 :
24159 :
24160 :
24161 :
24162 0 : return jresult;
24163 : }
24164 :
24165 :
24166 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetStatistics(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5) {
24167 0 : jint jresult = 0 ;
24168 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24169 : double arg2 ;
24170 : double arg3 ;
24171 : double arg4 ;
24172 : double arg5 ;
24173 : CPLErr result;
24174 :
24175 : (void)jenv;
24176 : (void)jcls;
24177 : (void)jarg1_;
24178 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24179 0 : arg2 = (double)jarg2;
24180 0 : arg3 = (double)jarg3;
24181 0 : arg4 = (double)jarg4;
24182 0 : arg5 = (double)jarg5;
24183 0 : result = (CPLErr)GDALRasterBandShadow_SetStatistics(arg1,arg2,arg3,arg4,arg5);
24184 0 : jresult = (jint)result;
24185 0 : return jresult;
24186 : }
24187 :
24188 :
24189 10 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetOverviewCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24190 10 : jint jresult = 0 ;
24191 10 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24192 : int result;
24193 :
24194 : (void)jenv;
24195 : (void)jcls;
24196 : (void)jarg1_;
24197 10 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24198 10 : result = (int)GDALRasterBandShadow_GetOverviewCount(arg1);
24199 10 : jresult = (jint)result;
24200 10 : return jresult;
24201 : }
24202 :
24203 :
24204 6 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetOverview(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
24205 6 : jlong jresult = 0 ;
24206 6 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24207 : int arg2 ;
24208 6 : GDALRasterBandShadow *result = 0 ;
24209 :
24210 : (void)jenv;
24211 : (void)jcls;
24212 : (void)jarg1_;
24213 6 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24214 6 : arg2 = (int)jarg2;
24215 6 : result = (GDALRasterBandShadow *)GDALRasterBandShadow_GetOverview(arg1,arg2);
24216 6 : *(GDALRasterBandShadow **)&jresult = result;
24217 6 : return jresult;
24218 : }
24219 :
24220 :
24221 3 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1Checksum(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5) {
24222 3 : jint jresult = 0 ;
24223 3 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24224 : int arg2 ;
24225 : int arg3 ;
24226 : int arg4 ;
24227 : int arg5 ;
24228 : int result;
24229 :
24230 : (void)jenv;
24231 : (void)jcls;
24232 : (void)jarg1_;
24233 3 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24234 3 : arg2 = (int)jarg2;
24235 3 : arg3 = (int)jarg3;
24236 3 : arg4 = (int)jarg4;
24237 3 : arg5 = (int)jarg5;
24238 3 : result = (int)GDALRasterBandShadow_Checksum(arg1,arg2,arg3,arg4,arg5);
24239 3 : jresult = (jint)result;
24240 3 : return jresult;
24241 : }
24242 :
24243 :
24244 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeRasterMinMax_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jint jarg3) {
24245 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24246 : double *arg2 ;
24247 : int arg3 ;
24248 :
24249 : (void)jenv;
24250 : (void)jcls;
24251 : (void)jarg1_;
24252 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24253 : {
24254 : /* %typemap(in) (double argout[ANY]) */
24255 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 2) {
24256 : char errorMsg[512];
24257 0 : sprintf(errorMsg, "array of size %d expected", 2);
24258 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
24259 0 : return ;
24260 : }
24261 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
24262 : }
24263 0 : arg3 = (int)jarg3;
24264 0 : GDALRasterBandShadow_ComputeRasterMinMax__SWIG_0(arg1,arg2,arg3);
24265 : {
24266 : /* %typemap(argout) (double argout[ANY]) */
24267 : }
24268 : {
24269 : /* %typemap(freearg) (double argout[ANY]) */
24270 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
24271 : }
24272 : }
24273 :
24274 :
24275 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeRasterMinMax_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) {
24276 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24277 : double *arg2 ;
24278 :
24279 : (void)jenv;
24280 : (void)jcls;
24281 : (void)jarg1_;
24282 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24283 : {
24284 : /* %typemap(in) (double argout[ANY]) */
24285 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 2) {
24286 : char errorMsg[512];
24287 0 : sprintf(errorMsg, "array of size %d expected", 2);
24288 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
24289 0 : return ;
24290 : }
24291 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
24292 : }
24293 0 : GDALRasterBandShadow_ComputeRasterMinMax__SWIG_0(arg1,arg2);
24294 : {
24295 : /* %typemap(argout) (double argout[ANY]) */
24296 : }
24297 : {
24298 : /* %typemap(freearg) (double argout[ANY]) */
24299 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
24300 : }
24301 : }
24302 :
24303 :
24304 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeBandStats_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jint jarg3) {
24305 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24306 : double *arg2 ;
24307 : int arg3 ;
24308 :
24309 : (void)jenv;
24310 : (void)jcls;
24311 : (void)jarg1_;
24312 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24313 : {
24314 : /* %typemap(in) (double argout[ANY]) */
24315 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 2) {
24316 : char errorMsg[512];
24317 0 : sprintf(errorMsg, "array of size %d expected", 2);
24318 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
24319 0 : return ;
24320 : }
24321 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
24322 : }
24323 0 : arg3 = (int)jarg3;
24324 0 : GDALRasterBandShadow_ComputeBandStats__SWIG_0(arg1,arg2,arg3);
24325 : {
24326 : /* %typemap(argout) (double argout[ANY]) */
24327 : }
24328 : {
24329 : /* %typemap(freearg) (double argout[ANY]) */
24330 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
24331 : }
24332 : }
24333 :
24334 :
24335 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ComputeBandStats_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) {
24336 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24337 : double *arg2 ;
24338 :
24339 : (void)jenv;
24340 : (void)jcls;
24341 : (void)jarg1_;
24342 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24343 : {
24344 : /* %typemap(in) (double argout[ANY]) */
24345 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 2) {
24346 : char errorMsg[512];
24347 0 : sprintf(errorMsg, "array of size %d expected", 2);
24348 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
24349 0 : return ;
24350 : }
24351 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
24352 : }
24353 0 : GDALRasterBandShadow_ComputeBandStats__SWIG_0(arg1,arg2);
24354 : {
24355 : /* %typemap(argout) (double argout[ANY]) */
24356 : }
24357 : {
24358 : /* %typemap(freearg) (double argout[ANY]) */
24359 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
24360 : }
24361 : }
24362 :
24363 :
24364 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1Fill_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3) {
24365 0 : jint jresult = 0 ;
24366 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24367 : double arg2 ;
24368 : double arg3 ;
24369 : CPLErr result;
24370 :
24371 : (void)jenv;
24372 : (void)jcls;
24373 : (void)jarg1_;
24374 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24375 0 : arg2 = (double)jarg2;
24376 0 : arg3 = (double)jarg3;
24377 0 : result = (CPLErr)GDALRasterBandShadow_Fill__SWIG_0(arg1,arg2,arg3);
24378 0 : jresult = (jint)result;
24379 0 : return jresult;
24380 : }
24381 :
24382 :
24383 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1Fill_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2) {
24384 0 : jint jresult = 0 ;
24385 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24386 : double arg2 ;
24387 : CPLErr result;
24388 :
24389 : (void)jenv;
24390 : (void)jcls;
24391 : (void)jarg1_;
24392 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24393 0 : arg2 = (double)jarg2;
24394 0 : result = (CPLErr)GDALRasterBandShadow_Fill__SWIG_0(arg1,arg2);
24395 0 : jresult = (jint)result;
24396 0 : return jresult;
24397 : }
24398 :
24399 :
24400 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1FlushCache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24401 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24402 :
24403 : (void)jenv;
24404 : (void)jcls;
24405 : (void)jarg1_;
24406 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24407 0 : GDALRasterBandShadow_FlushCache(arg1);
24408 0 : }
24409 :
24410 :
24411 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetRasterColorTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24412 0 : jlong jresult = 0 ;
24413 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24414 0 : GDALColorTableShadow *result = 0 ;
24415 :
24416 : (void)jenv;
24417 : (void)jcls;
24418 : (void)jarg1_;
24419 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24420 0 : result = (GDALColorTableShadow *)GDALRasterBandShadow_GetRasterColorTable(arg1);
24421 0 : *(GDALColorTableShadow **)&jresult = result;
24422 0 : return jresult;
24423 : }
24424 :
24425 :
24426 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetColorTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24427 0 : jlong jresult = 0 ;
24428 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24429 0 : GDALColorTableShadow *result = 0 ;
24430 :
24431 : (void)jenv;
24432 : (void)jcls;
24433 : (void)jarg1_;
24434 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24435 0 : result = (GDALColorTableShadow *)GDALRasterBandShadow_GetColorTable(arg1);
24436 0 : *(GDALColorTableShadow **)&jresult = result;
24437 0 : return jresult;
24438 : }
24439 :
24440 :
24441 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetRasterColorTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
24442 0 : jint jresult = 0 ;
24443 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24444 0 : GDALColorTableShadow *arg2 = (GDALColorTableShadow *) 0 ;
24445 : int result;
24446 :
24447 : (void)jenv;
24448 : (void)jcls;
24449 : (void)jarg1_;
24450 : (void)jarg2_;
24451 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24452 0 : arg2 = *(GDALColorTableShadow **)&jarg2;
24453 0 : result = (int)GDALRasterBandShadow_SetRasterColorTable(arg1,arg2);
24454 0 : jresult = (jint)result;
24455 0 : return jresult;
24456 : }
24457 :
24458 :
24459 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetColorTable(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
24460 0 : jint jresult = 0 ;
24461 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24462 0 : GDALColorTableShadow *arg2 = (GDALColorTableShadow *) 0 ;
24463 : int result;
24464 :
24465 : (void)jenv;
24466 : (void)jcls;
24467 : (void)jarg1_;
24468 : (void)jarg2_;
24469 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24470 0 : arg2 = *(GDALColorTableShadow **)&jarg2;
24471 0 : result = (int)GDALRasterBandShadow_SetColorTable(arg1,arg2);
24472 0 : jresult = (jint)result;
24473 0 : return jresult;
24474 : }
24475 :
24476 :
24477 1 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetDefaultRAT(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24478 1 : jlong jresult = 0 ;
24479 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24480 1 : GDALRasterAttributeTableShadow *result = 0 ;
24481 :
24482 : (void)jenv;
24483 : (void)jcls;
24484 : (void)jarg1_;
24485 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24486 1 : result = (GDALRasterAttributeTableShadow *)GDALRasterBandShadow_GetDefaultRAT(arg1);
24487 1 : *(GDALRasterAttributeTableShadow **)&jresult = result;
24488 1 : return jresult;
24489 : }
24490 :
24491 :
24492 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetDefaultRAT(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
24493 0 : jint jresult = 0 ;
24494 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24495 0 : GDALRasterAttributeTableShadow *arg2 = (GDALRasterAttributeTableShadow *) 0 ;
24496 : int result;
24497 :
24498 : (void)jenv;
24499 : (void)jcls;
24500 : (void)jarg1_;
24501 : (void)jarg2_;
24502 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24503 0 : arg2 = *(GDALRasterAttributeTableShadow **)&jarg2;
24504 0 : result = (int)GDALRasterBandShadow_SetDefaultRAT(arg1,arg2);
24505 0 : jresult = (jint)result;
24506 0 : return jresult;
24507 : }
24508 :
24509 :
24510 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetMaskBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24511 0 : jlong jresult = 0 ;
24512 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24513 0 : GDALRasterBandShadow *result = 0 ;
24514 :
24515 : (void)jenv;
24516 : (void)jcls;
24517 : (void)jarg1_;
24518 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24519 0 : result = (GDALRasterBandShadow *)GDALRasterBandShadow_GetMaskBand(arg1);
24520 0 : *(GDALRasterBandShadow **)&jresult = result;
24521 0 : return jresult;
24522 : }
24523 :
24524 :
24525 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetMaskFlags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24526 1 : jint jresult = 0 ;
24527 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24528 : int result;
24529 :
24530 : (void)jenv;
24531 : (void)jcls;
24532 : (void)jarg1_;
24533 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24534 1 : result = (int)GDALRasterBandShadow_GetMaskFlags(arg1);
24535 1 : jresult = (jint)result;
24536 1 : return jresult;
24537 : }
24538 :
24539 :
24540 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1CreateMaskBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
24541 0 : jint jresult = 0 ;
24542 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24543 : int arg2 ;
24544 : CPLErr result;
24545 :
24546 : (void)jenv;
24547 : (void)jcls;
24548 : (void)jarg1_;
24549 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24550 0 : arg2 = (int)jarg2;
24551 0 : result = (CPLErr)GDALRasterBandShadow_CreateMaskBand(arg1,arg2);
24552 0 : jresult = (jint)result;
24553 0 : return jresult;
24554 : }
24555 :
24556 :
24557 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Band_1IsMaskBand(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24558 0 : jboolean jresult = 0 ;
24559 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24560 : bool result;
24561 :
24562 : (void)jenv;
24563 : (void)jcls;
24564 : (void)jarg1_;
24565 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24566 0 : result = (bool)GDALRasterBandShadow_IsMaskBand(arg1);
24567 0 : jresult = (jboolean)result;
24568 0 : return jresult;
24569 : }
24570 :
24571 :
24572 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetDefaultHistogram(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jintArray jarg4) {
24573 0 : jint jresult = 0 ;
24574 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24575 : double arg2 ;
24576 : double arg3 ;
24577 : int arg4 ;
24578 0 : int *arg5 = (int *) 0 ;
24579 : CPLErr result;
24580 :
24581 : (void)jenv;
24582 : (void)jcls;
24583 : (void)jarg1_;
24584 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24585 0 : arg2 = (double)jarg2;
24586 0 : arg3 = (double)jarg3;
24587 : {
24588 : /* %typemap(in) (int nList, int* pList) */
24589 : /* check if is List */
24590 0 : if (jarg4)
24591 : {
24592 0 : arg4 = jenv->GetArrayLength(jarg4);
24593 0 : if (arg4 == 0)
24594 0 : arg5 = NULL;
24595 : else
24596 0 : arg5 = (int *)jenv->GetIntArrayElements(jarg4, NULL);
24597 : }
24598 : else
24599 : {
24600 0 : arg4 = 0;
24601 0 : arg5 = NULL;
24602 : }
24603 : }
24604 0 : result = (CPLErr)GDALRasterBandShadow_SetDefaultHistogram(arg1,arg2,arg3,arg4,arg5);
24605 0 : jresult = (jint)result;
24606 : {
24607 : /* %typemap(argout) (int nList, int* pList) */
24608 : }
24609 : {
24610 : /* %typemap(freearg) (int nList, int* pList) */
24611 0 : if (arg5) {
24612 0 : jenv->ReleaseIntArrayElements(jarg4, (jint*)arg5, JNI_ABORT);
24613 : }
24614 : }
24615 0 : return jresult;
24616 : }
24617 :
24618 :
24619 1 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_Band_1HasArbitraryOverviews(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24620 1 : jboolean jresult = 0 ;
24621 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24622 : bool result;
24623 :
24624 : (void)jenv;
24625 : (void)jcls;
24626 : (void)jarg1_;
24627 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24628 1 : result = (bool)GDALRasterBandShadow_HasArbitraryOverviews(arg1);
24629 1 : jresult = (jboolean)result;
24630 1 : return jresult;
24631 : }
24632 :
24633 :
24634 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetCategoryNames(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24635 0 : jobject jresult = 0 ;
24636 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24637 0 : char **result = 0 ;
24638 :
24639 : (void)jenv;
24640 : (void)jcls;
24641 : (void)jarg1_;
24642 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24643 0 : result = (char **)GDALRasterBandShadow_GetCategoryNames(arg1);
24644 : {
24645 : /* %typemap(out) char **options */
24646 0 : char **stringarray = result;
24647 0 : const jclass vector = jenv->FindClass("java/util/Vector");
24648 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
24649 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
24650 :
24651 0 : jresult = jenv->NewObject(vector, constructor);
24652 0 : if ( stringarray != NULL ) {
24653 0 : while(*stringarray != NULL) {
24654 : /*printf("working on string %s\n", *stringarray);*/
24655 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
24656 0 : jenv->CallBooleanMethod(jresult, add, value);
24657 0 : jenv->DeleteLocalRef(value);
24658 0 : stringarray++;
24659 : }
24660 : }
24661 : }
24662 0 : return jresult;
24663 : }
24664 :
24665 :
24666 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SetCategoryNames(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
24667 0 : jint jresult = 0 ;
24668 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24669 0 : char **arg2 = (char **) 0 ;
24670 : CPLErr result;
24671 :
24672 : (void)jenv;
24673 : (void)jcls;
24674 : (void)jarg1_;
24675 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24676 : {
24677 : /* %typemap(in) char **options */
24678 0 : arg2 = NULL;
24679 0 : if(jarg2 != 0) {
24680 0 : const jclass vector = jenv->FindClass("java/util/Vector");
24681 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
24682 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
24683 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
24684 : "()Ljava/util/Enumeration;");
24685 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
24686 : "hasMoreElements", "()Z");
24687 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
24688 : "nextElement", "()Ljava/lang/Object;");
24689 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
24690 0 : hasMoreElements == NULL || getNextElement == NULL) {
24691 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
24692 0 : return 0;
24693 : }
24694 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
24695 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
24696 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
24697 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
24698 : {
24699 0 : CSLDestroy(arg2);
24700 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
24701 0 : return 0;
24702 : }
24703 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
24704 0 : arg2 = CSLAddString(arg2, valptr);
24705 0 : jenv->ReleaseStringUTFChars(value, valptr);
24706 : }
24707 : }
24708 : }
24709 0 : result = (CPLErr)GDALRasterBandShadow_SetCategoryNames(arg1,arg2);
24710 0 : jresult = (jint)result;
24711 : {
24712 : /* %typemap(freearg) char **options */
24713 0 : CSLDestroy( arg2 );
24714 : }
24715 0 : return jresult;
24716 : }
24717 :
24718 :
24719 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AdviseRead_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8, jobject jarg9) {
24720 0 : jint jresult = 0 ;
24721 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24722 : int arg2 ;
24723 : int arg3 ;
24724 : int arg4 ;
24725 : int arg5 ;
24726 0 : int *arg6 = (int *) 0 ;
24727 0 : int *arg7 = (int *) 0 ;
24728 0 : GDALDataType *arg8 = (GDALDataType *) 0 ;
24729 0 : char **arg9 = (char **) 0 ;
24730 : CPLErr result;
24731 :
24732 : (void)jenv;
24733 : (void)jcls;
24734 : (void)jarg1_;
24735 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24736 0 : arg2 = (int)jarg2;
24737 0 : arg3 = (int)jarg3;
24738 0 : arg4 = (int)jarg4;
24739 0 : arg5 = (int)jarg5;
24740 0 : arg6 = *(int **)&jarg6;
24741 0 : arg7 = *(int **)&jarg7;
24742 0 : arg8 = *(GDALDataType **)&jarg8;
24743 : {
24744 : /* %typemap(in) char **options */
24745 0 : arg9 = NULL;
24746 0 : if(jarg9 != 0) {
24747 0 : const jclass vector = jenv->FindClass("java/util/Vector");
24748 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
24749 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
24750 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
24751 : "()Ljava/util/Enumeration;");
24752 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
24753 : "hasMoreElements", "()Z");
24754 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
24755 : "nextElement", "()Ljava/lang/Object;");
24756 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
24757 0 : hasMoreElements == NULL || getNextElement == NULL) {
24758 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
24759 0 : return 0;
24760 : }
24761 0 : for (jobject keys = jenv->CallObjectMethod(jarg9, elements);
24762 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
24763 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
24764 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
24765 : {
24766 0 : CSLDestroy(arg9);
24767 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
24768 0 : return 0;
24769 : }
24770 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
24771 0 : arg9 = CSLAddString(arg9, valptr);
24772 0 : jenv->ReleaseStringUTFChars(value, valptr);
24773 : }
24774 : }
24775 : }
24776 0 : result = (CPLErr)GDALRasterBandShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
24777 0 : jresult = (jint)result;
24778 : {
24779 : /* %typemap(freearg) char **options */
24780 0 : CSLDestroy( arg9 );
24781 : }
24782 0 : return jresult;
24783 : }
24784 :
24785 :
24786 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AdviseRead_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7, jlong jarg8) {
24787 0 : jint jresult = 0 ;
24788 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24789 : int arg2 ;
24790 : int arg3 ;
24791 : int arg4 ;
24792 : int arg5 ;
24793 0 : int *arg6 = (int *) 0 ;
24794 0 : int *arg7 = (int *) 0 ;
24795 0 : GDALDataType *arg8 = (GDALDataType *) 0 ;
24796 : CPLErr result;
24797 :
24798 : (void)jenv;
24799 : (void)jcls;
24800 : (void)jarg1_;
24801 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24802 0 : arg2 = (int)jarg2;
24803 0 : arg3 = (int)jarg3;
24804 0 : arg4 = (int)jarg4;
24805 0 : arg5 = (int)jarg5;
24806 0 : arg6 = *(int **)&jarg6;
24807 0 : arg7 = *(int **)&jarg7;
24808 0 : arg8 = *(GDALDataType **)&jarg8;
24809 0 : result = (CPLErr)GDALRasterBandShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24810 0 : jresult = (jint)result;
24811 0 : return jresult;
24812 : }
24813 :
24814 :
24815 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AdviseRead_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6, jlong jarg7) {
24816 0 : jint jresult = 0 ;
24817 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24818 : int arg2 ;
24819 : int arg3 ;
24820 : int arg4 ;
24821 : int arg5 ;
24822 0 : int *arg6 = (int *) 0 ;
24823 0 : int *arg7 = (int *) 0 ;
24824 : CPLErr result;
24825 :
24826 : (void)jenv;
24827 : (void)jcls;
24828 : (void)jarg1_;
24829 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24830 0 : arg2 = (int)jarg2;
24831 0 : arg3 = (int)jarg3;
24832 0 : arg4 = (int)jarg4;
24833 0 : arg5 = (int)jarg5;
24834 0 : arg6 = *(int **)&jarg6;
24835 0 : arg7 = *(int **)&jarg7;
24836 0 : result = (CPLErr)GDALRasterBandShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
24837 0 : jresult = (jint)result;
24838 0 : return jresult;
24839 : }
24840 :
24841 :
24842 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AdviseRead_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jlong jarg6) {
24843 0 : jint jresult = 0 ;
24844 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24845 : int arg2 ;
24846 : int arg3 ;
24847 : int arg4 ;
24848 : int arg5 ;
24849 0 : int *arg6 = (int *) 0 ;
24850 : CPLErr result;
24851 :
24852 : (void)jenv;
24853 : (void)jcls;
24854 : (void)jarg1_;
24855 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24856 0 : arg2 = (int)jarg2;
24857 0 : arg3 = (int)jarg3;
24858 0 : arg4 = (int)jarg4;
24859 0 : arg5 = (int)jarg5;
24860 0 : arg6 = *(int **)&jarg6;
24861 0 : result = (CPLErr)GDALRasterBandShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
24862 0 : jresult = (jint)result;
24863 0 : return jresult;
24864 : }
24865 :
24866 :
24867 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AdviseRead_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5) {
24868 0 : jint jresult = 0 ;
24869 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24870 : int arg2 ;
24871 : int arg3 ;
24872 : int arg4 ;
24873 : int arg5 ;
24874 : CPLErr result;
24875 :
24876 : (void)jenv;
24877 : (void)jcls;
24878 : (void)jarg1_;
24879 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24880 0 : arg2 = (int)jarg2;
24881 0 : arg3 = (int)jarg3;
24882 0 : arg4 = (int)jarg4;
24883 0 : arg5 = (int)jarg5;
24884 0 : result = (CPLErr)GDALRasterBandShadow_AdviseRead__SWIG_0(arg1,arg2,arg3,arg4,arg5);
24885 0 : jresult = (jint)result;
24886 0 : return jresult;
24887 : }
24888 :
24889 :
24890 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1AsMDArray(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
24891 0 : jlong jresult = 0 ;
24892 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24893 0 : GDALMDArrayHS *result = 0 ;
24894 :
24895 : (void)jenv;
24896 : (void)jcls;
24897 : (void)jarg1_;
24898 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24899 0 : result = (GDALMDArrayHS *)GDALRasterBandShadow_AsMDArray(arg1);
24900 0 : *(GDALMDArrayHS **)&jresult = result;
24901 0 : return jresult;
24902 : }
24903 :
24904 :
24905 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Band_1_1EnablePixelTypeSignedByteWarning(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
24906 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24907 : bool arg2 ;
24908 :
24909 : (void)jenv;
24910 : (void)jcls;
24911 : (void)jarg1_;
24912 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24913 0 : arg2 = jarg2 ? true : false;
24914 0 : GDALRasterBandShadow__EnablePixelTypeSignedByteWarning(arg1,arg2);
24915 0 : }
24916 :
24917 :
24918 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1Direct_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jint jarg11, jint jarg12) {
24919 0 : jint jresult = 0 ;
24920 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24921 : int arg2 ;
24922 : int arg3 ;
24923 : int arg4 ;
24924 : int arg5 ;
24925 : int arg6 ;
24926 : int arg7 ;
24927 : GDALDataType arg8 ;
24928 0 : void *arg9 = (void *) 0 ;
24929 : size_t arg10 ;
24930 : int arg11 ;
24931 : int arg12 ;
24932 : CPLErr result;
24933 :
24934 : (void)jenv;
24935 : (void)jcls;
24936 : (void)jarg1_;
24937 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24938 0 : arg2 = (int)jarg2;
24939 0 : arg3 = (int)jarg3;
24940 0 : arg4 = (int)jarg4;
24941 0 : arg5 = (int)jarg5;
24942 0 : arg6 = (int)jarg6;
24943 0 : arg7 = (int)jarg7;
24944 0 : arg8 = (GDALDataType)jarg8;
24945 : {
24946 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
24947 0 : if (jarg9 == 0)
24948 : {
24949 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
24950 0 : return 0;
24951 : }
24952 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
24953 0 : if (arg9 == NULL)
24954 : {
24955 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
24956 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
24957 0 : return 0;
24958 : }
24959 :
24960 : /* The cast to size_t is actually not that correct, but anyway afterwards */
24961 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
24962 : /* so truncating to INT_MAX is OK */
24963 :
24964 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
24965 : }
24966 0 : arg11 = (int)jarg11;
24967 0 : arg12 = (int)jarg12;
24968 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
24969 0 : jresult = (jint)result;
24970 0 : return jresult;
24971 : }
24972 :
24973 :
24974 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1Direct_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jint jarg11) {
24975 0 : jint jresult = 0 ;
24976 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
24977 : int arg2 ;
24978 : int arg3 ;
24979 : int arg4 ;
24980 : int arg5 ;
24981 : int arg6 ;
24982 : int arg7 ;
24983 : GDALDataType arg8 ;
24984 0 : void *arg9 = (void *) 0 ;
24985 : size_t arg10 ;
24986 : int arg11 ;
24987 : CPLErr result;
24988 :
24989 : (void)jenv;
24990 : (void)jcls;
24991 : (void)jarg1_;
24992 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
24993 0 : arg2 = (int)jarg2;
24994 0 : arg3 = (int)jarg3;
24995 0 : arg4 = (int)jarg4;
24996 0 : arg5 = (int)jarg5;
24997 0 : arg6 = (int)jarg6;
24998 0 : arg7 = (int)jarg7;
24999 0 : arg8 = (GDALDataType)jarg8;
25000 : {
25001 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
25002 0 : if (jarg9 == 0)
25003 : {
25004 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25005 0 : return 0;
25006 : }
25007 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
25008 0 : if (arg9 == NULL)
25009 : {
25010 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25011 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
25012 0 : return 0;
25013 : }
25014 :
25015 : /* The cast to size_t is actually not that correct, but anyway afterwards */
25016 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
25017 : /* so truncating to INT_MAX is OK */
25018 :
25019 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
25020 : }
25021 0 : arg11 = (int)jarg11;
25022 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25023 0 : jresult = (jint)result;
25024 0 : return jresult;
25025 : }
25026 :
25027 :
25028 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1Direct_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9) {
25029 0 : jint jresult = 0 ;
25030 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25031 : int arg2 ;
25032 : int arg3 ;
25033 : int arg4 ;
25034 : int arg5 ;
25035 : int arg6 ;
25036 : int arg7 ;
25037 : GDALDataType arg8 ;
25038 0 : void *arg9 = (void *) 0 ;
25039 : size_t arg10 ;
25040 : CPLErr result;
25041 :
25042 : (void)jenv;
25043 : (void)jcls;
25044 : (void)jarg1_;
25045 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25046 0 : arg2 = (int)jarg2;
25047 0 : arg3 = (int)jarg3;
25048 0 : arg4 = (int)jarg4;
25049 0 : arg5 = (int)jarg5;
25050 0 : arg6 = (int)jarg6;
25051 0 : arg7 = (int)jarg7;
25052 0 : arg8 = (GDALDataType)jarg8;
25053 : {
25054 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
25055 0 : if (jarg9 == 0)
25056 : {
25057 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25058 0 : return 0;
25059 : }
25060 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
25061 0 : if (arg9 == NULL)
25062 : {
25063 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25064 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
25065 0 : return 0;
25066 : }
25067 :
25068 : /* The cast to size_t is actually not that correct, but anyway afterwards */
25069 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
25070 : /* so truncating to INT_MAX is OK */
25071 :
25072 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
25073 : }
25074 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25075 0 : jresult = (jint)result;
25076 0 : return jresult;
25077 : }
25078 :
25079 :
25080 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jint jarg11, jint jarg12) {
25081 0 : jint jresult = 0 ;
25082 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25083 : int arg2 ;
25084 : int arg3 ;
25085 : int arg4 ;
25086 : int arg5 ;
25087 : int arg6 ;
25088 : int arg7 ;
25089 : GDALDataType arg8 ;
25090 0 : char *arg9 = (char *) 0 ;
25091 : size_t arg10 ;
25092 : int arg11 ;
25093 : int arg12 ;
25094 : CPLErr result;
25095 :
25096 : (void)jenv;
25097 : (void)jcls;
25098 : (void)jarg1_;
25099 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25100 0 : arg2 = (int)jarg2;
25101 0 : arg3 = (int)jarg3;
25102 0 : arg4 = (int)jarg4;
25103 0 : arg5 = (int)jarg5;
25104 0 : arg6 = (int)jarg6;
25105 0 : arg7 = (int)jarg7;
25106 0 : arg8 = (GDALDataType)jarg8;
25107 : {
25108 0 : if (jarg9 == 0)
25109 : {
25110 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25111 0 : return 0;
25112 : }
25113 :
25114 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
25115 0 : arg9 = (char*) malloc(arg10);
25116 :
25117 0 : if (arg9 == NULL)
25118 : {
25119 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25120 : "Unable to allocate temporary buffer.");
25121 0 : return 0;
25122 : }
25123 : }
25124 0 : arg11 = (int)jarg11;
25125 0 : arg12 = (int)jarg12;
25126 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25127 0 : jresult = (jint)result;
25128 : {
25129 0 : if (result == CE_None) // testing the CPL result
25130 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
25131 :
25132 0 : free(arg9);
25133 : }
25134 0 : return jresult;
25135 : }
25136 :
25137 :
25138 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jint jarg11) {
25139 0 : jint jresult = 0 ;
25140 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25141 : int arg2 ;
25142 : int arg3 ;
25143 : int arg4 ;
25144 : int arg5 ;
25145 : int arg6 ;
25146 : int arg7 ;
25147 : GDALDataType arg8 ;
25148 0 : char *arg9 = (char *) 0 ;
25149 : size_t arg10 ;
25150 : int arg11 ;
25151 : CPLErr result;
25152 :
25153 : (void)jenv;
25154 : (void)jcls;
25155 : (void)jarg1_;
25156 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25157 0 : arg2 = (int)jarg2;
25158 0 : arg3 = (int)jarg3;
25159 0 : arg4 = (int)jarg4;
25160 0 : arg5 = (int)jarg5;
25161 0 : arg6 = (int)jarg6;
25162 0 : arg7 = (int)jarg7;
25163 0 : arg8 = (GDALDataType)jarg8;
25164 : {
25165 0 : if (jarg9 == 0)
25166 : {
25167 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25168 0 : return 0;
25169 : }
25170 :
25171 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
25172 0 : arg9 = (char*) malloc(arg10);
25173 :
25174 0 : if (arg9 == NULL)
25175 : {
25176 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25177 : "Unable to allocate temporary buffer.");
25178 0 : return 0;
25179 : }
25180 : }
25181 0 : arg11 = (int)jarg11;
25182 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25183 0 : jresult = (jint)result;
25184 : {
25185 0 : if (result == CE_None) // testing the CPL result
25186 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
25187 :
25188 0 : free(arg9);
25189 : }
25190 0 : return jresult;
25191 : }
25192 :
25193 :
25194 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9) {
25195 0 : jint jresult = 0 ;
25196 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25197 : int arg2 ;
25198 : int arg3 ;
25199 : int arg4 ;
25200 : int arg5 ;
25201 : int arg6 ;
25202 : int arg7 ;
25203 : GDALDataType arg8 ;
25204 0 : char *arg9 = (char *) 0 ;
25205 : size_t arg10 ;
25206 : CPLErr result;
25207 :
25208 : (void)jenv;
25209 : (void)jcls;
25210 : (void)jarg1_;
25211 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25212 0 : arg2 = (int)jarg2;
25213 0 : arg3 = (int)jarg3;
25214 0 : arg4 = (int)jarg4;
25215 0 : arg5 = (int)jarg5;
25216 0 : arg6 = (int)jarg6;
25217 0 : arg7 = (int)jarg7;
25218 0 : arg8 = (GDALDataType)jarg8;
25219 : {
25220 0 : if (jarg9 == 0)
25221 : {
25222 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25223 0 : return 0;
25224 : }
25225 :
25226 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
25227 0 : arg9 = (char*) malloc(arg10);
25228 :
25229 0 : if (arg9 == NULL)
25230 : {
25231 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25232 : "Unable to allocate temporary buffer.");
25233 0 : return 0;
25234 : }
25235 : }
25236 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25237 0 : jresult = (jint)result;
25238 : {
25239 0 : if (result == CE_None) // testing the CPL result
25240 0 : jenv->SetByteArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jbyte*)arg9);
25241 :
25242 0 : free(arg9);
25243 : }
25244 0 : return jresult;
25245 : }
25246 :
25247 :
25248 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jint jarg11, jint jarg12) {
25249 0 : jint jresult = 0 ;
25250 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25251 : int arg2 ;
25252 : int arg3 ;
25253 : int arg4 ;
25254 : int arg5 ;
25255 : int arg6 ;
25256 : int arg7 ;
25257 : GDALDataType arg8 ;
25258 0 : short *arg9 = (short *) 0 ;
25259 : size_t arg10 ;
25260 : int arg11 ;
25261 : int arg12 ;
25262 : CPLErr result;
25263 :
25264 : (void)jenv;
25265 : (void)jcls;
25266 : (void)jarg1_;
25267 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25268 0 : arg2 = (int)jarg2;
25269 0 : arg3 = (int)jarg3;
25270 0 : arg4 = (int)jarg4;
25271 0 : arg5 = (int)jarg5;
25272 0 : arg6 = (int)jarg6;
25273 0 : arg7 = (int)jarg7;
25274 0 : arg8 = (GDALDataType)jarg8;
25275 : {
25276 0 : if (jarg9 == 0)
25277 : {
25278 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25279 0 : return 0;
25280 : }
25281 :
25282 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
25283 0 : arg9 = (short*) malloc(arg10);
25284 :
25285 0 : if (arg9 == NULL)
25286 : {
25287 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25288 : "Unable to allocate temporary buffer.");
25289 0 : return 0;
25290 : }
25291 : }
25292 0 : arg11 = (int)jarg11;
25293 0 : arg12 = (int)jarg12;
25294 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25295 0 : jresult = (jint)result;
25296 : {
25297 0 : if (result == CE_None) // testing the CPL result
25298 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
25299 :
25300 0 : free(arg9);
25301 : }
25302 0 : return jresult;
25303 : }
25304 :
25305 :
25306 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jint jarg11) {
25307 0 : jint jresult = 0 ;
25308 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25309 : int arg2 ;
25310 : int arg3 ;
25311 : int arg4 ;
25312 : int arg5 ;
25313 : int arg6 ;
25314 : int arg7 ;
25315 : GDALDataType arg8 ;
25316 0 : short *arg9 = (short *) 0 ;
25317 : size_t arg10 ;
25318 : int arg11 ;
25319 : CPLErr result;
25320 :
25321 : (void)jenv;
25322 : (void)jcls;
25323 : (void)jarg1_;
25324 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25325 0 : arg2 = (int)jarg2;
25326 0 : arg3 = (int)jarg3;
25327 0 : arg4 = (int)jarg4;
25328 0 : arg5 = (int)jarg5;
25329 0 : arg6 = (int)jarg6;
25330 0 : arg7 = (int)jarg7;
25331 0 : arg8 = (GDALDataType)jarg8;
25332 : {
25333 0 : if (jarg9 == 0)
25334 : {
25335 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25336 0 : return 0;
25337 : }
25338 :
25339 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
25340 0 : arg9 = (short*) malloc(arg10);
25341 :
25342 0 : if (arg9 == NULL)
25343 : {
25344 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25345 : "Unable to allocate temporary buffer.");
25346 0 : return 0;
25347 : }
25348 : }
25349 0 : arg11 = (int)jarg11;
25350 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25351 0 : jresult = (jint)result;
25352 : {
25353 0 : if (result == CE_None) // testing the CPL result
25354 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
25355 :
25356 0 : free(arg9);
25357 : }
25358 0 : return jresult;
25359 : }
25360 :
25361 :
25362 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9) {
25363 0 : jint jresult = 0 ;
25364 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25365 : int arg2 ;
25366 : int arg3 ;
25367 : int arg4 ;
25368 : int arg5 ;
25369 : int arg6 ;
25370 : int arg7 ;
25371 : GDALDataType arg8 ;
25372 0 : short *arg9 = (short *) 0 ;
25373 : size_t arg10 ;
25374 : CPLErr result;
25375 :
25376 : (void)jenv;
25377 : (void)jcls;
25378 : (void)jarg1_;
25379 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25380 0 : arg2 = (int)jarg2;
25381 0 : arg3 = (int)jarg3;
25382 0 : arg4 = (int)jarg4;
25383 0 : arg5 = (int)jarg5;
25384 0 : arg6 = (int)jarg6;
25385 0 : arg7 = (int)jarg7;
25386 0 : arg8 = (GDALDataType)jarg8;
25387 : {
25388 0 : if (jarg9 == 0)
25389 : {
25390 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25391 0 : return 0;
25392 : }
25393 :
25394 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
25395 0 : arg9 = (short*) malloc(arg10);
25396 :
25397 0 : if (arg9 == NULL)
25398 : {
25399 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25400 : "Unable to allocate temporary buffer.");
25401 0 : return 0;
25402 : }
25403 : }
25404 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25405 0 : jresult = (jint)result;
25406 : {
25407 0 : if (result == CE_None) // testing the CPL result
25408 0 : jenv->SetShortArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jshort*)arg9);
25409 :
25410 0 : free(arg9);
25411 : }
25412 0 : return jresult;
25413 : }
25414 :
25415 :
25416 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jint jarg11, jint jarg12) {
25417 0 : jint jresult = 0 ;
25418 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25419 : int arg2 ;
25420 : int arg3 ;
25421 : int arg4 ;
25422 : int arg5 ;
25423 : int arg6 ;
25424 : int arg7 ;
25425 : GDALDataType arg8 ;
25426 0 : int *arg9 = (int *) 0 ;
25427 : size_t arg10 ;
25428 : int arg11 ;
25429 : int arg12 ;
25430 : CPLErr result;
25431 :
25432 : (void)jenv;
25433 : (void)jcls;
25434 : (void)jarg1_;
25435 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25436 0 : arg2 = (int)jarg2;
25437 0 : arg3 = (int)jarg3;
25438 0 : arg4 = (int)jarg4;
25439 0 : arg5 = (int)jarg5;
25440 0 : arg6 = (int)jarg6;
25441 0 : arg7 = (int)jarg7;
25442 0 : arg8 = (GDALDataType)jarg8;
25443 : {
25444 0 : if (jarg9 == 0)
25445 : {
25446 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25447 0 : return 0;
25448 : }
25449 :
25450 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
25451 0 : arg9 = (int*) malloc(arg10);
25452 :
25453 0 : if (arg9 == NULL)
25454 : {
25455 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25456 : "Unable to allocate temporary buffer.");
25457 0 : return 0;
25458 : }
25459 : }
25460 0 : arg11 = (int)jarg11;
25461 0 : arg12 = (int)jarg12;
25462 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25463 0 : jresult = (jint)result;
25464 : {
25465 0 : if (result == CE_None) // testing the CPL result
25466 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
25467 :
25468 0 : free(arg9);
25469 : }
25470 0 : return jresult;
25471 : }
25472 :
25473 :
25474 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jint jarg11) {
25475 0 : jint jresult = 0 ;
25476 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25477 : int arg2 ;
25478 : int arg3 ;
25479 : int arg4 ;
25480 : int arg5 ;
25481 : int arg6 ;
25482 : int arg7 ;
25483 : GDALDataType arg8 ;
25484 0 : int *arg9 = (int *) 0 ;
25485 : size_t arg10 ;
25486 : int arg11 ;
25487 : CPLErr result;
25488 :
25489 : (void)jenv;
25490 : (void)jcls;
25491 : (void)jarg1_;
25492 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25493 0 : arg2 = (int)jarg2;
25494 0 : arg3 = (int)jarg3;
25495 0 : arg4 = (int)jarg4;
25496 0 : arg5 = (int)jarg5;
25497 0 : arg6 = (int)jarg6;
25498 0 : arg7 = (int)jarg7;
25499 0 : arg8 = (GDALDataType)jarg8;
25500 : {
25501 0 : if (jarg9 == 0)
25502 : {
25503 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25504 0 : return 0;
25505 : }
25506 :
25507 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
25508 0 : arg9 = (int*) malloc(arg10);
25509 :
25510 0 : if (arg9 == NULL)
25511 : {
25512 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25513 : "Unable to allocate temporary buffer.");
25514 0 : return 0;
25515 : }
25516 : }
25517 0 : arg11 = (int)jarg11;
25518 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25519 0 : jresult = (jint)result;
25520 : {
25521 0 : if (result == CE_None) // testing the CPL result
25522 0 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
25523 :
25524 0 : free(arg9);
25525 : }
25526 0 : return jresult;
25527 : }
25528 :
25529 :
25530 39995 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9) {
25531 39995 : jint jresult = 0 ;
25532 39995 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25533 : int arg2 ;
25534 : int arg3 ;
25535 : int arg4 ;
25536 : int arg5 ;
25537 : int arg6 ;
25538 : int arg7 ;
25539 : GDALDataType arg8 ;
25540 39995 : int *arg9 = (int *) 0 ;
25541 : size_t arg10 ;
25542 : CPLErr result;
25543 :
25544 : (void)jenv;
25545 : (void)jcls;
25546 : (void)jarg1_;
25547 39995 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25548 39995 : arg2 = (int)jarg2;
25549 39995 : arg3 = (int)jarg3;
25550 39995 : arg4 = (int)jarg4;
25551 39995 : arg5 = (int)jarg5;
25552 39995 : arg6 = (int)jarg6;
25553 39995 : arg7 = (int)jarg7;
25554 39995 : arg8 = (GDALDataType)jarg8;
25555 : {
25556 39995 : if (jarg9 == 0)
25557 : {
25558 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25559 0 : return 0;
25560 : }
25561 :
25562 39995 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
25563 39992 : arg9 = (int*) malloc(arg10);
25564 :
25565 39992 : if (arg9 == NULL)
25566 : {
25567 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25568 : "Unable to allocate temporary buffer.");
25569 0 : return 0;
25570 : }
25571 : }
25572 39992 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25573 39998 : jresult = (jint)result;
25574 : {
25575 39998 : if (result == CE_None) // testing the CPL result
25576 39999 : jenv->SetIntArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jint*)arg9);
25577 :
25578 39996 : free(arg9);
25579 : }
25580 39996 : return jresult;
25581 : }
25582 :
25583 :
25584 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jint jarg11, jint jarg12) {
25585 0 : jint jresult = 0 ;
25586 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25587 : int arg2 ;
25588 : int arg3 ;
25589 : int arg4 ;
25590 : int arg5 ;
25591 : int arg6 ;
25592 : int arg7 ;
25593 : GDALDataType arg8 ;
25594 0 : int64_t *arg9 = (int64_t *) 0 ;
25595 : size_t arg10 ;
25596 : int arg11 ;
25597 : int arg12 ;
25598 : CPLErr result;
25599 :
25600 : (void)jenv;
25601 : (void)jcls;
25602 : (void)jarg1_;
25603 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25604 0 : arg2 = (int)jarg2;
25605 0 : arg3 = (int)jarg3;
25606 0 : arg4 = (int)jarg4;
25607 0 : arg5 = (int)jarg5;
25608 0 : arg6 = (int)jarg6;
25609 0 : arg7 = (int)jarg7;
25610 0 : arg8 = (GDALDataType)jarg8;
25611 : {
25612 0 : if (jarg9 == 0)
25613 : {
25614 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25615 0 : return 0;
25616 : }
25617 :
25618 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
25619 0 : arg9 = (int64_t*) malloc(arg10);
25620 :
25621 0 : if (arg9 == NULL)
25622 : {
25623 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25624 : "Unable to allocate temporary buffer.");
25625 0 : return 0;
25626 : }
25627 : }
25628 0 : arg11 = (int)jarg11;
25629 0 : arg12 = (int)jarg12;
25630 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25631 0 : jresult = (jint)result;
25632 : {
25633 0 : if (result == CE_None) // testing the CPL result
25634 0 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
25635 :
25636 0 : free(arg9);
25637 : }
25638 0 : return jresult;
25639 : }
25640 :
25641 :
25642 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jint jarg11) {
25643 0 : jint jresult = 0 ;
25644 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25645 : int arg2 ;
25646 : int arg3 ;
25647 : int arg4 ;
25648 : int arg5 ;
25649 : int arg6 ;
25650 : int arg7 ;
25651 : GDALDataType arg8 ;
25652 0 : int64_t *arg9 = (int64_t *) 0 ;
25653 : size_t arg10 ;
25654 : int arg11 ;
25655 : CPLErr result;
25656 :
25657 : (void)jenv;
25658 : (void)jcls;
25659 : (void)jarg1_;
25660 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25661 0 : arg2 = (int)jarg2;
25662 0 : arg3 = (int)jarg3;
25663 0 : arg4 = (int)jarg4;
25664 0 : arg5 = (int)jarg5;
25665 0 : arg6 = (int)jarg6;
25666 0 : arg7 = (int)jarg7;
25667 0 : arg8 = (GDALDataType)jarg8;
25668 : {
25669 0 : if (jarg9 == 0)
25670 : {
25671 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25672 0 : return 0;
25673 : }
25674 :
25675 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
25676 0 : arg9 = (int64_t*) malloc(arg10);
25677 :
25678 0 : if (arg9 == NULL)
25679 : {
25680 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25681 : "Unable to allocate temporary buffer.");
25682 0 : return 0;
25683 : }
25684 : }
25685 0 : arg11 = (int)jarg11;
25686 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25687 0 : jresult = (jint)result;
25688 : {
25689 0 : if (result == CE_None) // testing the CPL result
25690 0 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
25691 :
25692 0 : free(arg9);
25693 : }
25694 0 : return jresult;
25695 : }
25696 :
25697 :
25698 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_111(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9) {
25699 1 : jint jresult = 0 ;
25700 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25701 : int arg2 ;
25702 : int arg3 ;
25703 : int arg4 ;
25704 : int arg5 ;
25705 : int arg6 ;
25706 : int arg7 ;
25707 : GDALDataType arg8 ;
25708 1 : int64_t *arg9 = (int64_t *) 0 ;
25709 : size_t arg10 ;
25710 : CPLErr result;
25711 :
25712 : (void)jenv;
25713 : (void)jcls;
25714 : (void)jarg1_;
25715 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25716 1 : arg2 = (int)jarg2;
25717 1 : arg3 = (int)jarg3;
25718 1 : arg4 = (int)jarg4;
25719 1 : arg5 = (int)jarg5;
25720 1 : arg6 = (int)jarg6;
25721 1 : arg7 = (int)jarg7;
25722 1 : arg8 = (GDALDataType)jarg8;
25723 : {
25724 1 : if (jarg9 == 0)
25725 : {
25726 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25727 0 : return 0;
25728 : }
25729 :
25730 1 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
25731 1 : arg9 = (int64_t*) malloc(arg10);
25732 :
25733 1 : if (arg9 == NULL)
25734 : {
25735 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25736 : "Unable to allocate temporary buffer.");
25737 0 : return 0;
25738 : }
25739 : }
25740 1 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25741 1 : jresult = (jint)result;
25742 : {
25743 1 : if (result == CE_None) // testing the CPL result
25744 1 : jenv->SetLongArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jlong*)arg9);
25745 :
25746 1 : free(arg9);
25747 : }
25748 1 : return jresult;
25749 : }
25750 :
25751 :
25752 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_112(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jint jarg11, jint jarg12) {
25753 0 : jint jresult = 0 ;
25754 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25755 : int arg2 ;
25756 : int arg3 ;
25757 : int arg4 ;
25758 : int arg5 ;
25759 : int arg6 ;
25760 : int arg7 ;
25761 : GDALDataType arg8 ;
25762 0 : float *arg9 = (float *) 0 ;
25763 : size_t arg10 ;
25764 : int arg11 ;
25765 : int arg12 ;
25766 : CPLErr result;
25767 :
25768 : (void)jenv;
25769 : (void)jcls;
25770 : (void)jarg1_;
25771 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25772 0 : arg2 = (int)jarg2;
25773 0 : arg3 = (int)jarg3;
25774 0 : arg4 = (int)jarg4;
25775 0 : arg5 = (int)jarg5;
25776 0 : arg6 = (int)jarg6;
25777 0 : arg7 = (int)jarg7;
25778 0 : arg8 = (GDALDataType)jarg8;
25779 : {
25780 0 : if (jarg9 == 0)
25781 : {
25782 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25783 0 : return 0;
25784 : }
25785 :
25786 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
25787 0 : arg9 = (float*) malloc(arg10);
25788 :
25789 0 : if (arg9 == NULL)
25790 : {
25791 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25792 : "Unable to allocate temporary buffer.");
25793 0 : return 0;
25794 : }
25795 : }
25796 0 : arg11 = (int)jarg11;
25797 0 : arg12 = (int)jarg12;
25798 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25799 0 : jresult = (jint)result;
25800 : {
25801 0 : if (result == CE_None) // testing the CPL result
25802 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
25803 :
25804 0 : free(arg9);
25805 : }
25806 0 : return jresult;
25807 : }
25808 :
25809 :
25810 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_113(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jint jarg11) {
25811 0 : jint jresult = 0 ;
25812 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25813 : int arg2 ;
25814 : int arg3 ;
25815 : int arg4 ;
25816 : int arg5 ;
25817 : int arg6 ;
25818 : int arg7 ;
25819 : GDALDataType arg8 ;
25820 0 : float *arg9 = (float *) 0 ;
25821 : size_t arg10 ;
25822 : int arg11 ;
25823 : CPLErr result;
25824 :
25825 : (void)jenv;
25826 : (void)jcls;
25827 : (void)jarg1_;
25828 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25829 0 : arg2 = (int)jarg2;
25830 0 : arg3 = (int)jarg3;
25831 0 : arg4 = (int)jarg4;
25832 0 : arg5 = (int)jarg5;
25833 0 : arg6 = (int)jarg6;
25834 0 : arg7 = (int)jarg7;
25835 0 : arg8 = (GDALDataType)jarg8;
25836 : {
25837 0 : if (jarg9 == 0)
25838 : {
25839 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25840 0 : return 0;
25841 : }
25842 :
25843 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
25844 0 : arg9 = (float*) malloc(arg10);
25845 :
25846 0 : if (arg9 == NULL)
25847 : {
25848 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25849 : "Unable to allocate temporary buffer.");
25850 0 : return 0;
25851 : }
25852 : }
25853 0 : arg11 = (int)jarg11;
25854 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
25855 0 : jresult = (jint)result;
25856 : {
25857 0 : if (result == CE_None) // testing the CPL result
25858 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
25859 :
25860 0 : free(arg9);
25861 : }
25862 0 : return jresult;
25863 : }
25864 :
25865 :
25866 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_114(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9) {
25867 0 : jint jresult = 0 ;
25868 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25869 : int arg2 ;
25870 : int arg3 ;
25871 : int arg4 ;
25872 : int arg5 ;
25873 : int arg6 ;
25874 : int arg7 ;
25875 : GDALDataType arg8 ;
25876 0 : float *arg9 = (float *) 0 ;
25877 : size_t arg10 ;
25878 : CPLErr result;
25879 :
25880 : (void)jenv;
25881 : (void)jcls;
25882 : (void)jarg1_;
25883 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25884 0 : arg2 = (int)jarg2;
25885 0 : arg3 = (int)jarg3;
25886 0 : arg4 = (int)jarg4;
25887 0 : arg5 = (int)jarg5;
25888 0 : arg6 = (int)jarg6;
25889 0 : arg7 = (int)jarg7;
25890 0 : arg8 = (GDALDataType)jarg8;
25891 : {
25892 0 : if (jarg9 == 0)
25893 : {
25894 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25895 0 : return 0;
25896 : }
25897 :
25898 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
25899 0 : arg9 = (float*) malloc(arg10);
25900 :
25901 0 : if (arg9 == NULL)
25902 : {
25903 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25904 : "Unable to allocate temporary buffer.");
25905 0 : return 0;
25906 : }
25907 : }
25908 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
25909 0 : jresult = (jint)result;
25910 : {
25911 0 : if (result == CE_None) // testing the CPL result
25912 0 : jenv->SetFloatArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jfloat*)arg9);
25913 :
25914 0 : free(arg9);
25915 : }
25916 0 : return jresult;
25917 : }
25918 :
25919 :
25920 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_115(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jint jarg11, jint jarg12) {
25921 0 : jint jresult = 0 ;
25922 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25923 : int arg2 ;
25924 : int arg3 ;
25925 : int arg4 ;
25926 : int arg5 ;
25927 : int arg6 ;
25928 : int arg7 ;
25929 : GDALDataType arg8 ;
25930 0 : double *arg9 = (double *) 0 ;
25931 : size_t arg10 ;
25932 : int arg11 ;
25933 : int arg12 ;
25934 : CPLErr result;
25935 :
25936 : (void)jenv;
25937 : (void)jcls;
25938 : (void)jarg1_;
25939 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25940 0 : arg2 = (int)jarg2;
25941 0 : arg3 = (int)jarg3;
25942 0 : arg4 = (int)jarg4;
25943 0 : arg5 = (int)jarg5;
25944 0 : arg6 = (int)jarg6;
25945 0 : arg7 = (int)jarg7;
25946 0 : arg8 = (GDALDataType)jarg8;
25947 : {
25948 0 : if (jarg9 == 0)
25949 : {
25950 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
25951 0 : return 0;
25952 : }
25953 :
25954 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
25955 0 : arg9 = (double*) malloc(arg10);
25956 :
25957 0 : if (arg9 == NULL)
25958 : {
25959 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
25960 : "Unable to allocate temporary buffer.");
25961 0 : return 0;
25962 : }
25963 : }
25964 0 : arg11 = (int)jarg11;
25965 0 : arg12 = (int)jarg12;
25966 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
25967 0 : jresult = (jint)result;
25968 : {
25969 0 : if (result == CE_None) // testing the CPL result
25970 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
25971 :
25972 0 : free(arg9);
25973 : }
25974 0 : return jresult;
25975 : }
25976 :
25977 :
25978 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_116(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jint jarg11) {
25979 0 : jint jresult = 0 ;
25980 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
25981 : int arg2 ;
25982 : int arg3 ;
25983 : int arg4 ;
25984 : int arg5 ;
25985 : int arg6 ;
25986 : int arg7 ;
25987 : GDALDataType arg8 ;
25988 0 : double *arg9 = (double *) 0 ;
25989 : size_t arg10 ;
25990 : int arg11 ;
25991 : CPLErr result;
25992 :
25993 : (void)jenv;
25994 : (void)jcls;
25995 : (void)jarg1_;
25996 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
25997 0 : arg2 = (int)jarg2;
25998 0 : arg3 = (int)jarg3;
25999 0 : arg4 = (int)jarg4;
26000 0 : arg5 = (int)jarg5;
26001 0 : arg6 = (int)jarg6;
26002 0 : arg7 = (int)jarg7;
26003 0 : arg8 = (GDALDataType)jarg8;
26004 : {
26005 0 : if (jarg9 == 0)
26006 : {
26007 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26008 0 : return 0;
26009 : }
26010 :
26011 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
26012 0 : arg9 = (double*) malloc(arg10);
26013 :
26014 0 : if (arg9 == NULL)
26015 : {
26016 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26017 : "Unable to allocate temporary buffer.");
26018 0 : return 0;
26019 : }
26020 : }
26021 0 : arg11 = (int)jarg11;
26022 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26023 0 : jresult = (jint)result;
26024 : {
26025 0 : if (result == CE_None) // testing the CPL result
26026 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
26027 :
26028 0 : free(arg9);
26029 : }
26030 0 : return jresult;
26031 : }
26032 :
26033 :
26034 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadRaster_1_1SWIG_117(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9) {
26035 0 : jint jresult = 0 ;
26036 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26037 : int arg2 ;
26038 : int arg3 ;
26039 : int arg4 ;
26040 : int arg5 ;
26041 : int arg6 ;
26042 : int arg7 ;
26043 : GDALDataType arg8 ;
26044 0 : double *arg9 = (double *) 0 ;
26045 : size_t arg10 ;
26046 : CPLErr result;
26047 :
26048 : (void)jenv;
26049 : (void)jcls;
26050 : (void)jarg1_;
26051 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26052 0 : arg2 = (int)jarg2;
26053 0 : arg3 = (int)jarg3;
26054 0 : arg4 = (int)jarg4;
26055 0 : arg5 = (int)jarg5;
26056 0 : arg6 = (int)jarg6;
26057 0 : arg7 = (int)jarg7;
26058 0 : arg8 = (GDALDataType)jarg8;
26059 : {
26060 0 : if (jarg9 == 0)
26061 : {
26062 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26063 0 : return 0;
26064 : }
26065 :
26066 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
26067 0 : arg9 = (double*) malloc(arg10);
26068 :
26069 0 : if (arg9 == NULL)
26070 : {
26071 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26072 : "Unable to allocate temporary buffer.");
26073 0 : return 0;
26074 : }
26075 : }
26076 0 : result = (CPLErr)GDALRasterBandShadow_ReadRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26077 0 : jresult = (jint)result;
26078 : {
26079 0 : if (result == CE_None) // testing the CPL result
26080 0 : jenv->SetDoubleArrayRegion(jarg9, (jsize)0, jenv->GetArrayLength(jarg9), (jdouble*)arg9);
26081 :
26082 0 : free(arg9);
26083 : }
26084 0 : return jresult;
26085 : }
26086 :
26087 :
26088 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1Direct_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jint jarg11, jint jarg12) {
26089 0 : jint jresult = 0 ;
26090 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26091 : int arg2 ;
26092 : int arg3 ;
26093 : int arg4 ;
26094 : int arg5 ;
26095 : int arg6 ;
26096 : int arg7 ;
26097 : GDALDataType arg8 ;
26098 0 : void *arg9 = (void *) 0 ;
26099 : size_t arg10 ;
26100 : int arg11 ;
26101 : int arg12 ;
26102 : CPLErr result;
26103 :
26104 : (void)jenv;
26105 : (void)jcls;
26106 : (void)jarg1_;
26107 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26108 0 : arg2 = (int)jarg2;
26109 0 : arg3 = (int)jarg3;
26110 0 : arg4 = (int)jarg4;
26111 0 : arg5 = (int)jarg5;
26112 0 : arg6 = (int)jarg6;
26113 0 : arg7 = (int)jarg7;
26114 0 : arg8 = (GDALDataType)jarg8;
26115 : {
26116 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
26117 0 : if (jarg9 == 0)
26118 : {
26119 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26120 0 : return 0;
26121 : }
26122 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
26123 0 : if (arg9 == NULL)
26124 : {
26125 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26126 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
26127 0 : return 0;
26128 : }
26129 :
26130 : /* The cast to size_t is actually not that correct, but anyway afterwards */
26131 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
26132 : /* so truncating to INT_MAX is OK */
26133 :
26134 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
26135 : }
26136 0 : arg11 = (int)jarg11;
26137 0 : arg12 = (int)jarg12;
26138 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26139 0 : jresult = (jint)result;
26140 0 : return jresult;
26141 : }
26142 :
26143 :
26144 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1Direct_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9, jint jarg11) {
26145 0 : jint jresult = 0 ;
26146 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26147 : int arg2 ;
26148 : int arg3 ;
26149 : int arg4 ;
26150 : int arg5 ;
26151 : int arg6 ;
26152 : int arg7 ;
26153 : GDALDataType arg8 ;
26154 0 : void *arg9 = (void *) 0 ;
26155 : size_t arg10 ;
26156 : int arg11 ;
26157 : CPLErr result;
26158 :
26159 : (void)jenv;
26160 : (void)jcls;
26161 : (void)jarg1_;
26162 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26163 0 : arg2 = (int)jarg2;
26164 0 : arg3 = (int)jarg3;
26165 0 : arg4 = (int)jarg4;
26166 0 : arg5 = (int)jarg5;
26167 0 : arg6 = (int)jarg6;
26168 0 : arg7 = (int)jarg7;
26169 0 : arg8 = (GDALDataType)jarg8;
26170 : {
26171 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
26172 0 : if (jarg9 == 0)
26173 : {
26174 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26175 0 : return 0;
26176 : }
26177 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
26178 0 : if (arg9 == NULL)
26179 : {
26180 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26181 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
26182 0 : return 0;
26183 : }
26184 :
26185 : /* The cast to size_t is actually not that correct, but anyway afterwards */
26186 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
26187 : /* so truncating to INT_MAX is OK */
26188 :
26189 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
26190 : }
26191 0 : arg11 = (int)jarg11;
26192 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26193 0 : jresult = (jint)result;
26194 0 : return jresult;
26195 : }
26196 :
26197 :
26198 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1Direct_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jobject jarg9) {
26199 0 : jint jresult = 0 ;
26200 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26201 : int arg2 ;
26202 : int arg3 ;
26203 : int arg4 ;
26204 : int arg5 ;
26205 : int arg6 ;
26206 : int arg7 ;
26207 : GDALDataType arg8 ;
26208 0 : void *arg9 = (void *) 0 ;
26209 : size_t arg10 ;
26210 : CPLErr result;
26211 :
26212 : (void)jenv;
26213 : (void)jcls;
26214 : (void)jarg1_;
26215 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26216 0 : arg2 = (int)jarg2;
26217 0 : arg3 = (int)jarg3;
26218 0 : arg4 = (int)jarg4;
26219 0 : arg5 = (int)jarg5;
26220 0 : arg6 = (int)jarg6;
26221 0 : arg7 = (int)jarg7;
26222 0 : arg8 = (GDALDataType)jarg8;
26223 : {
26224 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
26225 0 : if (jarg9 == 0)
26226 : {
26227 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26228 0 : return 0;
26229 : }
26230 0 : arg9 = jenv->GetDirectBufferAddress(jarg9);
26231 0 : if (arg9 == NULL)
26232 : {
26233 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26234 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
26235 0 : return 0;
26236 : }
26237 :
26238 : /* The cast to size_t is actually not that correct, but anyway afterwards */
26239 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
26240 : /* so truncating to INT_MAX is OK */
26241 :
26242 0 : arg10 = (size_t) ((jenv->GetDirectBufferCapacity(jarg9) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg9));
26243 : }
26244 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster_Direct__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26245 0 : jresult = (jint)result;
26246 0 : return jresult;
26247 : }
26248 :
26249 :
26250 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jint jarg11, jint jarg12) {
26251 0 : jint jresult = 0 ;
26252 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26253 : int arg2 ;
26254 : int arg3 ;
26255 : int arg4 ;
26256 : int arg5 ;
26257 : int arg6 ;
26258 : int arg7 ;
26259 : GDALDataType arg8 ;
26260 0 : char *arg9 = (char *) 0 ;
26261 : size_t arg10 ;
26262 : int arg11 ;
26263 : int arg12 ;
26264 : CPLErr result;
26265 :
26266 : (void)jenv;
26267 : (void)jcls;
26268 : (void)jarg1_;
26269 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26270 0 : arg2 = (int)jarg2;
26271 0 : arg3 = (int)jarg3;
26272 0 : arg4 = (int)jarg4;
26273 0 : arg5 = (int)jarg5;
26274 0 : arg6 = (int)jarg6;
26275 0 : arg7 = (int)jarg7;
26276 0 : arg8 = (GDALDataType)jarg8;
26277 : {
26278 0 : if (jarg9 == 0)
26279 : {
26280 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26281 0 : return 0;
26282 : }
26283 :
26284 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
26285 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
26286 0 : if (arg9 == NULL)
26287 : {
26288 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26289 : "Unable to get buffer.");
26290 0 : return 0;
26291 : }
26292 : }
26293 0 : arg11 = (int)jarg11;
26294 0 : arg12 = (int)jarg12;
26295 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26296 0 : jresult = (jint)result;
26297 : {
26298 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
26299 : }
26300 0 : return jresult;
26301 : }
26302 :
26303 :
26304 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9, jint jarg11) {
26305 0 : jint jresult = 0 ;
26306 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26307 : int arg2 ;
26308 : int arg3 ;
26309 : int arg4 ;
26310 : int arg5 ;
26311 : int arg6 ;
26312 : int arg7 ;
26313 : GDALDataType arg8 ;
26314 0 : char *arg9 = (char *) 0 ;
26315 : size_t arg10 ;
26316 : int arg11 ;
26317 : CPLErr result;
26318 :
26319 : (void)jenv;
26320 : (void)jcls;
26321 : (void)jarg1_;
26322 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26323 0 : arg2 = (int)jarg2;
26324 0 : arg3 = (int)jarg3;
26325 0 : arg4 = (int)jarg4;
26326 0 : arg5 = (int)jarg5;
26327 0 : arg6 = (int)jarg6;
26328 0 : arg7 = (int)jarg7;
26329 0 : arg8 = (GDALDataType)jarg8;
26330 : {
26331 0 : if (jarg9 == 0)
26332 : {
26333 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26334 0 : return 0;
26335 : }
26336 :
26337 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
26338 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
26339 0 : if (arg9 == NULL)
26340 : {
26341 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26342 : "Unable to get buffer.");
26343 0 : return 0;
26344 : }
26345 : }
26346 0 : arg11 = (int)jarg11;
26347 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26348 0 : jresult = (jint)result;
26349 : {
26350 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
26351 : }
26352 0 : return jresult;
26353 : }
26354 :
26355 :
26356 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jbyteArray jarg9) {
26357 0 : jint jresult = 0 ;
26358 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26359 : int arg2 ;
26360 : int arg3 ;
26361 : int arg4 ;
26362 : int arg5 ;
26363 : int arg6 ;
26364 : int arg7 ;
26365 : GDALDataType arg8 ;
26366 0 : char *arg9 = (char *) 0 ;
26367 : size_t arg10 ;
26368 : CPLErr result;
26369 :
26370 : (void)jenv;
26371 : (void)jcls;
26372 : (void)jarg1_;
26373 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26374 0 : arg2 = (int)jarg2;
26375 0 : arg3 = (int)jarg3;
26376 0 : arg4 = (int)jarg4;
26377 0 : arg5 = (int)jarg5;
26378 0 : arg6 = (int)jarg6;
26379 0 : arg7 = (int)jarg7;
26380 0 : arg8 = (GDALDataType)jarg8;
26381 : {
26382 0 : if (jarg9 == 0)
26383 : {
26384 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26385 0 : return 0;
26386 : }
26387 :
26388 0 : arg10 = sizeof(char) * jenv->GetArrayLength(jarg9);
26389 0 : arg9 = (char*) jenv->GetByteArrayElements(jarg9, 0);
26390 0 : if (arg9 == NULL)
26391 : {
26392 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26393 : "Unable to get buffer.");
26394 0 : return 0;
26395 : }
26396 : }
26397 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26398 0 : jresult = (jint)result;
26399 : {
26400 0 : jenv->ReleaseByteArrayElements(jarg9, (jbyte*) arg9, JNI_ABORT);
26401 : }
26402 0 : return jresult;
26403 : }
26404 :
26405 :
26406 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jint jarg11, jint jarg12) {
26407 0 : jint jresult = 0 ;
26408 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26409 : int arg2 ;
26410 : int arg3 ;
26411 : int arg4 ;
26412 : int arg5 ;
26413 : int arg6 ;
26414 : int arg7 ;
26415 : GDALDataType arg8 ;
26416 0 : short *arg9 = (short *) 0 ;
26417 : size_t arg10 ;
26418 : int arg11 ;
26419 : int arg12 ;
26420 : CPLErr result;
26421 :
26422 : (void)jenv;
26423 : (void)jcls;
26424 : (void)jarg1_;
26425 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26426 0 : arg2 = (int)jarg2;
26427 0 : arg3 = (int)jarg3;
26428 0 : arg4 = (int)jarg4;
26429 0 : arg5 = (int)jarg5;
26430 0 : arg6 = (int)jarg6;
26431 0 : arg7 = (int)jarg7;
26432 0 : arg8 = (GDALDataType)jarg8;
26433 : {
26434 0 : if (jarg9 == 0)
26435 : {
26436 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26437 0 : return 0;
26438 : }
26439 :
26440 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
26441 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
26442 0 : if (arg9 == NULL)
26443 : {
26444 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26445 : "Unable to get buffer.");
26446 0 : return 0;
26447 : }
26448 : }
26449 0 : arg11 = (int)jarg11;
26450 0 : arg12 = (int)jarg12;
26451 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26452 0 : jresult = (jint)result;
26453 : {
26454 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
26455 : }
26456 0 : return jresult;
26457 : }
26458 :
26459 :
26460 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9, jint jarg11) {
26461 0 : jint jresult = 0 ;
26462 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26463 : int arg2 ;
26464 : int arg3 ;
26465 : int arg4 ;
26466 : int arg5 ;
26467 : int arg6 ;
26468 : int arg7 ;
26469 : GDALDataType arg8 ;
26470 0 : short *arg9 = (short *) 0 ;
26471 : size_t arg10 ;
26472 : int arg11 ;
26473 : CPLErr result;
26474 :
26475 : (void)jenv;
26476 : (void)jcls;
26477 : (void)jarg1_;
26478 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26479 0 : arg2 = (int)jarg2;
26480 0 : arg3 = (int)jarg3;
26481 0 : arg4 = (int)jarg4;
26482 0 : arg5 = (int)jarg5;
26483 0 : arg6 = (int)jarg6;
26484 0 : arg7 = (int)jarg7;
26485 0 : arg8 = (GDALDataType)jarg8;
26486 : {
26487 0 : if (jarg9 == 0)
26488 : {
26489 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26490 0 : return 0;
26491 : }
26492 :
26493 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
26494 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
26495 0 : if (arg9 == NULL)
26496 : {
26497 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26498 : "Unable to get buffer.");
26499 0 : return 0;
26500 : }
26501 : }
26502 0 : arg11 = (int)jarg11;
26503 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26504 0 : jresult = (jint)result;
26505 : {
26506 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
26507 : }
26508 0 : return jresult;
26509 : }
26510 :
26511 :
26512 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jshortArray jarg9) {
26513 0 : jint jresult = 0 ;
26514 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26515 : int arg2 ;
26516 : int arg3 ;
26517 : int arg4 ;
26518 : int arg5 ;
26519 : int arg6 ;
26520 : int arg7 ;
26521 : GDALDataType arg8 ;
26522 0 : short *arg9 = (short *) 0 ;
26523 : size_t arg10 ;
26524 : CPLErr result;
26525 :
26526 : (void)jenv;
26527 : (void)jcls;
26528 : (void)jarg1_;
26529 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26530 0 : arg2 = (int)jarg2;
26531 0 : arg3 = (int)jarg3;
26532 0 : arg4 = (int)jarg4;
26533 0 : arg5 = (int)jarg5;
26534 0 : arg6 = (int)jarg6;
26535 0 : arg7 = (int)jarg7;
26536 0 : arg8 = (GDALDataType)jarg8;
26537 : {
26538 0 : if (jarg9 == 0)
26539 : {
26540 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26541 0 : return 0;
26542 : }
26543 :
26544 0 : arg10 = sizeof(short) * jenv->GetArrayLength(jarg9);
26545 0 : arg9 = (short*) jenv->GetShortArrayElements(jarg9, 0);
26546 0 : if (arg9 == NULL)
26547 : {
26548 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26549 : "Unable to get buffer.");
26550 0 : return 0;
26551 : }
26552 : }
26553 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26554 0 : jresult = (jint)result;
26555 : {
26556 0 : jenv->ReleaseShortArrayElements(jarg9, (jshort*) arg9, JNI_ABORT);
26557 : }
26558 0 : return jresult;
26559 : }
26560 :
26561 :
26562 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jint jarg11, jint jarg12) {
26563 0 : jint jresult = 0 ;
26564 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26565 : int arg2 ;
26566 : int arg3 ;
26567 : int arg4 ;
26568 : int arg5 ;
26569 : int arg6 ;
26570 : int arg7 ;
26571 : GDALDataType arg8 ;
26572 0 : int *arg9 = (int *) 0 ;
26573 : size_t arg10 ;
26574 : int arg11 ;
26575 : int arg12 ;
26576 : CPLErr result;
26577 :
26578 : (void)jenv;
26579 : (void)jcls;
26580 : (void)jarg1_;
26581 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26582 0 : arg2 = (int)jarg2;
26583 0 : arg3 = (int)jarg3;
26584 0 : arg4 = (int)jarg4;
26585 0 : arg5 = (int)jarg5;
26586 0 : arg6 = (int)jarg6;
26587 0 : arg7 = (int)jarg7;
26588 0 : arg8 = (GDALDataType)jarg8;
26589 : {
26590 0 : if (jarg9 == 0)
26591 : {
26592 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26593 0 : return 0;
26594 : }
26595 :
26596 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
26597 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
26598 0 : if (arg9 == NULL)
26599 : {
26600 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26601 : "Unable to get buffer.");
26602 0 : return 0;
26603 : }
26604 : }
26605 0 : arg11 = (int)jarg11;
26606 0 : arg12 = (int)jarg12;
26607 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26608 0 : jresult = (jint)result;
26609 : {
26610 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
26611 : }
26612 0 : return jresult;
26613 : }
26614 :
26615 :
26616 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9, jint jarg11) {
26617 0 : jint jresult = 0 ;
26618 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26619 : int arg2 ;
26620 : int arg3 ;
26621 : int arg4 ;
26622 : int arg5 ;
26623 : int arg6 ;
26624 : int arg7 ;
26625 : GDALDataType arg8 ;
26626 0 : int *arg9 = (int *) 0 ;
26627 : size_t arg10 ;
26628 : int arg11 ;
26629 : CPLErr result;
26630 :
26631 : (void)jenv;
26632 : (void)jcls;
26633 : (void)jarg1_;
26634 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26635 0 : arg2 = (int)jarg2;
26636 0 : arg3 = (int)jarg3;
26637 0 : arg4 = (int)jarg4;
26638 0 : arg5 = (int)jarg5;
26639 0 : arg6 = (int)jarg6;
26640 0 : arg7 = (int)jarg7;
26641 0 : arg8 = (GDALDataType)jarg8;
26642 : {
26643 0 : if (jarg9 == 0)
26644 : {
26645 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26646 0 : return 0;
26647 : }
26648 :
26649 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
26650 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
26651 0 : if (arg9 == NULL)
26652 : {
26653 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26654 : "Unable to get buffer.");
26655 0 : return 0;
26656 : }
26657 : }
26658 0 : arg11 = (int)jarg11;
26659 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26660 0 : jresult = (jint)result;
26661 : {
26662 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
26663 : }
26664 0 : return jresult;
26665 : }
26666 :
26667 :
26668 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jintArray jarg9) {
26669 0 : jint jresult = 0 ;
26670 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26671 : int arg2 ;
26672 : int arg3 ;
26673 : int arg4 ;
26674 : int arg5 ;
26675 : int arg6 ;
26676 : int arg7 ;
26677 : GDALDataType arg8 ;
26678 0 : int *arg9 = (int *) 0 ;
26679 : size_t arg10 ;
26680 : CPLErr result;
26681 :
26682 : (void)jenv;
26683 : (void)jcls;
26684 : (void)jarg1_;
26685 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26686 0 : arg2 = (int)jarg2;
26687 0 : arg3 = (int)jarg3;
26688 0 : arg4 = (int)jarg4;
26689 0 : arg5 = (int)jarg5;
26690 0 : arg6 = (int)jarg6;
26691 0 : arg7 = (int)jarg7;
26692 0 : arg8 = (GDALDataType)jarg8;
26693 : {
26694 0 : if (jarg9 == 0)
26695 : {
26696 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26697 0 : return 0;
26698 : }
26699 :
26700 0 : arg10 = sizeof(int) * jenv->GetArrayLength(jarg9);
26701 0 : arg9 = (int*) jenv->GetIntArrayElements(jarg9, 0);
26702 0 : if (arg9 == NULL)
26703 : {
26704 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26705 : "Unable to get buffer.");
26706 0 : return 0;
26707 : }
26708 : }
26709 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_6(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26710 0 : jresult = (jint)result;
26711 : {
26712 0 : jenv->ReleaseIntArrayElements(jarg9, (jint*) arg9, JNI_ABORT);
26713 : }
26714 0 : return jresult;
26715 : }
26716 :
26717 :
26718 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_19(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jint jarg11, jint jarg12) {
26719 0 : jint jresult = 0 ;
26720 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26721 : int arg2 ;
26722 : int arg3 ;
26723 : int arg4 ;
26724 : int arg5 ;
26725 : int arg6 ;
26726 : int arg7 ;
26727 : GDALDataType arg8 ;
26728 0 : int64_t *arg9 = (int64_t *) 0 ;
26729 : size_t arg10 ;
26730 : int arg11 ;
26731 : int arg12 ;
26732 : CPLErr result;
26733 :
26734 : (void)jenv;
26735 : (void)jcls;
26736 : (void)jarg1_;
26737 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26738 0 : arg2 = (int)jarg2;
26739 0 : arg3 = (int)jarg3;
26740 0 : arg4 = (int)jarg4;
26741 0 : arg5 = (int)jarg5;
26742 0 : arg6 = (int)jarg6;
26743 0 : arg7 = (int)jarg7;
26744 0 : arg8 = (GDALDataType)jarg8;
26745 : {
26746 0 : if (jarg9 == 0)
26747 : {
26748 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26749 0 : return 0;
26750 : }
26751 :
26752 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
26753 0 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
26754 0 : if (arg9 == NULL)
26755 : {
26756 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26757 : "Unable to get buffer.");
26758 0 : return 0;
26759 : }
26760 : }
26761 0 : arg11 = (int)jarg11;
26762 0 : arg12 = (int)jarg12;
26763 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26764 0 : jresult = (jint)result;
26765 : {
26766 0 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
26767 : }
26768 0 : return jresult;
26769 : }
26770 :
26771 :
26772 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_110(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9, jint jarg11) {
26773 0 : jint jresult = 0 ;
26774 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26775 : int arg2 ;
26776 : int arg3 ;
26777 : int arg4 ;
26778 : int arg5 ;
26779 : int arg6 ;
26780 : int arg7 ;
26781 : GDALDataType arg8 ;
26782 0 : int64_t *arg9 = (int64_t *) 0 ;
26783 : size_t arg10 ;
26784 : int arg11 ;
26785 : CPLErr result;
26786 :
26787 : (void)jenv;
26788 : (void)jcls;
26789 : (void)jarg1_;
26790 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26791 0 : arg2 = (int)jarg2;
26792 0 : arg3 = (int)jarg3;
26793 0 : arg4 = (int)jarg4;
26794 0 : arg5 = (int)jarg5;
26795 0 : arg6 = (int)jarg6;
26796 0 : arg7 = (int)jarg7;
26797 0 : arg8 = (GDALDataType)jarg8;
26798 : {
26799 0 : if (jarg9 == 0)
26800 : {
26801 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26802 0 : return 0;
26803 : }
26804 :
26805 0 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
26806 0 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
26807 0 : if (arg9 == NULL)
26808 : {
26809 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26810 : "Unable to get buffer.");
26811 0 : return 0;
26812 : }
26813 : }
26814 0 : arg11 = (int)jarg11;
26815 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26816 0 : jresult = (jint)result;
26817 : {
26818 0 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
26819 : }
26820 0 : return jresult;
26821 : }
26822 :
26823 :
26824 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_111(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jlongArray jarg9) {
26825 1 : jint jresult = 0 ;
26826 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26827 : int arg2 ;
26828 : int arg3 ;
26829 : int arg4 ;
26830 : int arg5 ;
26831 : int arg6 ;
26832 : int arg7 ;
26833 : GDALDataType arg8 ;
26834 1 : int64_t *arg9 = (int64_t *) 0 ;
26835 : size_t arg10 ;
26836 : CPLErr result;
26837 :
26838 : (void)jenv;
26839 : (void)jcls;
26840 : (void)jarg1_;
26841 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26842 1 : arg2 = (int)jarg2;
26843 1 : arg3 = (int)jarg3;
26844 1 : arg4 = (int)jarg4;
26845 1 : arg5 = (int)jarg5;
26846 1 : arg6 = (int)jarg6;
26847 1 : arg7 = (int)jarg7;
26848 1 : arg8 = (GDALDataType)jarg8;
26849 : {
26850 1 : if (jarg9 == 0)
26851 : {
26852 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26853 0 : return 0;
26854 : }
26855 :
26856 1 : arg10 = sizeof(int64_t) * jenv->GetArrayLength(jarg9);
26857 1 : arg9 = (int64_t*) jenv->GetLongArrayElements(jarg9, 0);
26858 1 : if (arg9 == NULL)
26859 : {
26860 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26861 : "Unable to get buffer.");
26862 0 : return 0;
26863 : }
26864 : }
26865 1 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
26866 1 : jresult = (jint)result;
26867 : {
26868 1 : jenv->ReleaseLongArrayElements(jarg9, (jlong*) arg9, JNI_ABORT);
26869 : }
26870 1 : return jresult;
26871 : }
26872 :
26873 :
26874 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_112(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jint jarg11, jint jarg12) {
26875 0 : jint jresult = 0 ;
26876 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26877 : int arg2 ;
26878 : int arg3 ;
26879 : int arg4 ;
26880 : int arg5 ;
26881 : int arg6 ;
26882 : int arg7 ;
26883 : GDALDataType arg8 ;
26884 0 : float *arg9 = (float *) 0 ;
26885 : size_t arg10 ;
26886 : int arg11 ;
26887 : int arg12 ;
26888 : CPLErr result;
26889 :
26890 : (void)jenv;
26891 : (void)jcls;
26892 : (void)jarg1_;
26893 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26894 0 : arg2 = (int)jarg2;
26895 0 : arg3 = (int)jarg3;
26896 0 : arg4 = (int)jarg4;
26897 0 : arg5 = (int)jarg5;
26898 0 : arg6 = (int)jarg6;
26899 0 : arg7 = (int)jarg7;
26900 0 : arg8 = (GDALDataType)jarg8;
26901 : {
26902 0 : if (jarg9 == 0)
26903 : {
26904 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26905 0 : return 0;
26906 : }
26907 :
26908 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
26909 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
26910 0 : if (arg9 == NULL)
26911 : {
26912 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26913 : "Unable to get buffer.");
26914 0 : return 0;
26915 : }
26916 : }
26917 0 : arg11 = (int)jarg11;
26918 0 : arg12 = (int)jarg12;
26919 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
26920 0 : jresult = (jint)result;
26921 : {
26922 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
26923 : }
26924 0 : return jresult;
26925 : }
26926 :
26927 :
26928 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_113(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9, jint jarg11) {
26929 0 : jint jresult = 0 ;
26930 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26931 : int arg2 ;
26932 : int arg3 ;
26933 : int arg4 ;
26934 : int arg5 ;
26935 : int arg6 ;
26936 : int arg7 ;
26937 : GDALDataType arg8 ;
26938 0 : float *arg9 = (float *) 0 ;
26939 : size_t arg10 ;
26940 : int arg11 ;
26941 : CPLErr result;
26942 :
26943 : (void)jenv;
26944 : (void)jcls;
26945 : (void)jarg1_;
26946 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26947 0 : arg2 = (int)jarg2;
26948 0 : arg3 = (int)jarg3;
26949 0 : arg4 = (int)jarg4;
26950 0 : arg5 = (int)jarg5;
26951 0 : arg6 = (int)jarg6;
26952 0 : arg7 = (int)jarg7;
26953 0 : arg8 = (GDALDataType)jarg8;
26954 : {
26955 0 : if (jarg9 == 0)
26956 : {
26957 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
26958 0 : return 0;
26959 : }
26960 :
26961 0 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
26962 0 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
26963 0 : if (arg9 == NULL)
26964 : {
26965 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
26966 : "Unable to get buffer.");
26967 0 : return 0;
26968 : }
26969 : }
26970 0 : arg11 = (int)jarg11;
26971 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
26972 0 : jresult = (jint)result;
26973 : {
26974 0 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
26975 : }
26976 0 : return jresult;
26977 : }
26978 :
26979 :
26980 39986 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_114(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jfloatArray jarg9) {
26981 39986 : jint jresult = 0 ;
26982 39986 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
26983 : int arg2 ;
26984 : int arg3 ;
26985 : int arg4 ;
26986 : int arg5 ;
26987 : int arg6 ;
26988 : int arg7 ;
26989 : GDALDataType arg8 ;
26990 39986 : float *arg9 = (float *) 0 ;
26991 : size_t arg10 ;
26992 : CPLErr result;
26993 :
26994 : (void)jenv;
26995 : (void)jcls;
26996 : (void)jarg1_;
26997 39986 : arg1 = *(GDALRasterBandShadow **)&jarg1;
26998 39986 : arg2 = (int)jarg2;
26999 39986 : arg3 = (int)jarg3;
27000 39986 : arg4 = (int)jarg4;
27001 39986 : arg5 = (int)jarg5;
27002 39986 : arg6 = (int)jarg6;
27003 39986 : arg7 = (int)jarg7;
27004 39986 : arg8 = (GDALDataType)jarg8;
27005 : {
27006 39986 : if (jarg9 == 0)
27007 : {
27008 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27009 0 : return 0;
27010 : }
27011 :
27012 39986 : arg10 = sizeof(float) * jenv->GetArrayLength(jarg9);
27013 39989 : arg9 = (float*) jenv->GetFloatArrayElements(jarg9, 0);
27014 39991 : if (arg9 == NULL)
27015 : {
27016 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27017 : "Unable to get buffer.");
27018 0 : return 0;
27019 : }
27020 : }
27021 39991 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
27022 39982 : jresult = (jint)result;
27023 : {
27024 39982 : jenv->ReleaseFloatArrayElements(jarg9, (jfloat*) arg9, JNI_ABORT);
27025 : }
27026 39974 : return jresult;
27027 : }
27028 :
27029 :
27030 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_115(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jint jarg11, jint jarg12) {
27031 0 : jint jresult = 0 ;
27032 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27033 : int arg2 ;
27034 : int arg3 ;
27035 : int arg4 ;
27036 : int arg5 ;
27037 : int arg6 ;
27038 : int arg7 ;
27039 : GDALDataType arg8 ;
27040 0 : double *arg9 = (double *) 0 ;
27041 : size_t arg10 ;
27042 : int arg11 ;
27043 : int arg12 ;
27044 : CPLErr result;
27045 :
27046 : (void)jenv;
27047 : (void)jcls;
27048 : (void)jarg1_;
27049 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27050 0 : arg2 = (int)jarg2;
27051 0 : arg3 = (int)jarg3;
27052 0 : arg4 = (int)jarg4;
27053 0 : arg5 = (int)jarg5;
27054 0 : arg6 = (int)jarg6;
27055 0 : arg7 = (int)jarg7;
27056 0 : arg8 = (GDALDataType)jarg8;
27057 : {
27058 0 : if (jarg9 == 0)
27059 : {
27060 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27061 0 : return 0;
27062 : }
27063 :
27064 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
27065 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
27066 0 : if (arg9 == NULL)
27067 : {
27068 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27069 : "Unable to get buffer.");
27070 0 : return 0;
27071 : }
27072 : }
27073 0 : arg11 = (int)jarg11;
27074 0 : arg12 = (int)jarg12;
27075 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
27076 0 : jresult = (jint)result;
27077 : {
27078 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
27079 : }
27080 0 : return jresult;
27081 : }
27082 :
27083 :
27084 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_116(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9, jint jarg11) {
27085 0 : jint jresult = 0 ;
27086 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27087 : int arg2 ;
27088 : int arg3 ;
27089 : int arg4 ;
27090 : int arg5 ;
27091 : int arg6 ;
27092 : int arg7 ;
27093 : GDALDataType arg8 ;
27094 0 : double *arg9 = (double *) 0 ;
27095 : size_t arg10 ;
27096 : int arg11 ;
27097 : CPLErr result;
27098 :
27099 : (void)jenv;
27100 : (void)jcls;
27101 : (void)jarg1_;
27102 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27103 0 : arg2 = (int)jarg2;
27104 0 : arg3 = (int)jarg3;
27105 0 : arg4 = (int)jarg4;
27106 0 : arg5 = (int)jarg5;
27107 0 : arg6 = (int)jarg6;
27108 0 : arg7 = (int)jarg7;
27109 0 : arg8 = (GDALDataType)jarg8;
27110 : {
27111 0 : if (jarg9 == 0)
27112 : {
27113 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27114 0 : return 0;
27115 : }
27116 :
27117 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
27118 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
27119 0 : if (arg9 == NULL)
27120 : {
27121 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27122 : "Unable to get buffer.");
27123 0 : return 0;
27124 : }
27125 : }
27126 0 : arg11 = (int)jarg11;
27127 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
27128 0 : jresult = (jint)result;
27129 : {
27130 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
27131 : }
27132 0 : return jresult;
27133 : }
27134 :
27135 :
27136 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteRaster_1_1SWIG_117(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jint jarg8, jdoubleArray jarg9) {
27137 0 : jint jresult = 0 ;
27138 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27139 : int arg2 ;
27140 : int arg3 ;
27141 : int arg4 ;
27142 : int arg5 ;
27143 : int arg6 ;
27144 : int arg7 ;
27145 : GDALDataType arg8 ;
27146 0 : double *arg9 = (double *) 0 ;
27147 : size_t arg10 ;
27148 : CPLErr result;
27149 :
27150 : (void)jenv;
27151 : (void)jcls;
27152 : (void)jarg1_;
27153 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27154 0 : arg2 = (int)jarg2;
27155 0 : arg3 = (int)jarg3;
27156 0 : arg4 = (int)jarg4;
27157 0 : arg5 = (int)jarg5;
27158 0 : arg6 = (int)jarg6;
27159 0 : arg7 = (int)jarg7;
27160 0 : arg8 = (GDALDataType)jarg8;
27161 : {
27162 0 : if (jarg9 == 0)
27163 : {
27164 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27165 0 : return 0;
27166 : }
27167 :
27168 0 : arg10 = sizeof(double) * jenv->GetArrayLength(jarg9);
27169 0 : arg9 = (double*) jenv->GetDoubleArrayElements(jarg9, 0);
27170 0 : if (arg9 == NULL)
27171 : {
27172 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27173 : "Unable to get buffer.");
27174 0 : return 0;
27175 : }
27176 : }
27177 0 : result = (CPLErr)GDALRasterBandShadow_WriteRaster__SWIG_15(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
27178 0 : jresult = (jint)result;
27179 : {
27180 0 : jenv->ReleaseDoubleArrayElements(jarg9, (jdouble*) arg9, JNI_ABORT);
27181 : }
27182 0 : return jresult;
27183 : }
27184 :
27185 :
27186 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1ReadBlock_1Direct(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jobject jarg4) {
27187 0 : jint jresult = 0 ;
27188 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27189 : int arg2 ;
27190 : int arg3 ;
27191 0 : void *arg4 = (void *) 0 ;
27192 : size_t arg5 ;
27193 : CPLErr result;
27194 :
27195 : (void)jenv;
27196 : (void)jcls;
27197 : (void)jarg1_;
27198 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27199 0 : arg2 = (int)jarg2;
27200 0 : arg3 = (int)jarg3;
27201 : {
27202 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
27203 0 : if (jarg4 == 0)
27204 : {
27205 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27206 0 : return 0;
27207 : }
27208 0 : arg4 = jenv->GetDirectBufferAddress(jarg4);
27209 0 : if (arg4 == NULL)
27210 : {
27211 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27212 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
27213 0 : return 0;
27214 : }
27215 :
27216 : /* The cast to size_t is actually not that correct, but anyway afterwards */
27217 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
27218 : /* so truncating to INT_MAX is OK */
27219 :
27220 0 : arg5 = (size_t) ((jenv->GetDirectBufferCapacity(jarg4) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg4));
27221 : }
27222 0 : result = (CPLErr)GDALRasterBandShadow_ReadBlock_Direct(arg1,arg2,arg3,arg4,arg5);
27223 0 : jresult = (jint)result;
27224 0 : return jresult;
27225 : }
27226 :
27227 :
27228 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1WriteBlock_1Direct(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jobject jarg4) {
27229 0 : jint jresult = 0 ;
27230 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27231 : int arg2 ;
27232 : int arg3 ;
27233 0 : void *arg4 = (void *) 0 ;
27234 : size_t arg5 ;
27235 : CPLErr result;
27236 :
27237 : (void)jenv;
27238 : (void)jcls;
27239 : (void)jarg1_;
27240 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27241 0 : arg2 = (int)jarg2;
27242 0 : arg3 = (int)jarg3;
27243 : {
27244 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
27245 0 : if (jarg4 == 0)
27246 : {
27247 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
27248 0 : return 0;
27249 : }
27250 0 : arg4 = jenv->GetDirectBufferAddress(jarg4);
27251 0 : if (arg4 == NULL)
27252 : {
27253 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
27254 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
27255 0 : return 0;
27256 : }
27257 :
27258 : /* The cast to size_t is actually not that correct, but anyway afterwards */
27259 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
27260 : /* so truncating to INT_MAX is OK */
27261 :
27262 0 : arg5 = (size_t) ((jenv->GetDirectBufferCapacity(jarg4) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg4));
27263 : }
27264 0 : result = (CPLErr)GDALRasterBandShadow_WriteBlock_Direct(arg1,arg2,arg3,arg4,arg5);
27265 0 : jresult = (jint)result;
27266 0 : return jresult;
27267 : }
27268 :
27269 :
27270 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetHistogram_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jintArray jarg4, jboolean jarg6, jboolean jarg7, jobject jarg8) {
27271 0 : jint jresult = 0 ;
27272 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27273 : double arg2 ;
27274 : double arg3 ;
27275 : int arg4 ;
27276 0 : int *arg5 = (int *) 0 ;
27277 : bool arg6 ;
27278 : bool arg7 ;
27279 : GDALProgressFunc arg8 ;
27280 0 : void *arg9 = (void *) 0 ;
27281 : CPLErr result;
27282 :
27283 : (void)jenv;
27284 : (void)jcls;
27285 : JavaProgressData sProgressInfo;
27286 0 : sProgressInfo.jenv = jenv;
27287 0 : sProgressInfo.pJavaCallback = NULL;
27288 : (void)jarg1_;
27289 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27290 0 : arg2 = (double)jarg2;
27291 0 : arg3 = (double)jarg3;
27292 : {
27293 : /* %typemap(in) (int nList, int* pListOut) */
27294 : /* check if is List */
27295 0 : if (jarg4)
27296 : {
27297 0 : arg4 = jenv->GetArrayLength(jarg4);
27298 0 : arg5 = (int*) malloc(arg4 * sizeof(int));
27299 : }
27300 : else
27301 : {
27302 0 : arg4 = 0;
27303 0 : arg5 = NULL;
27304 : }
27305 : }
27306 0 : arg6 = jarg6 ? true : false;
27307 0 : arg7 = jarg7 ? true : false;
27308 : {
27309 0 : if ( jarg8 != 0 ) {
27310 0 : sProgressInfo.pJavaCallback = jarg8;
27311 0 : arg8 = JavaProgressProxy;
27312 0 : arg9 = &sProgressInfo;
27313 : }
27314 : else
27315 : {
27316 0 : arg8 = NULL;
27317 0 : arg9 = NULL;
27318 : }
27319 : }
27320 : {
27321 0 : if (!arg5) {
27322 : {
27323 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
27324 : };
27325 : }
27326 : }
27327 0 : result = (CPLErr)GDALRasterBandShadow_GetHistogram__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
27328 0 : jresult = (jint)result;
27329 : {
27330 : /* %typemap(argout) (int nList, int* pListOut) */
27331 : }
27332 : {
27333 : /* %typemap(freearg) (int nList, int* pListOut) */
27334 0 : if (arg5) {
27335 0 : jenv->SetIntArrayRegion(jarg4, 0, arg4, (jint*)arg5);
27336 0 : free((void*) arg5);
27337 : }
27338 : }
27339 0 : return jresult;
27340 : }
27341 :
27342 :
27343 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetHistogram_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jintArray jarg4, jboolean jarg6, jboolean jarg7) {
27344 0 : jint jresult = 0 ;
27345 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27346 : double arg2 ;
27347 : double arg3 ;
27348 : int arg4 ;
27349 0 : int *arg5 = (int *) 0 ;
27350 : bool arg6 ;
27351 : bool arg7 ;
27352 : CPLErr result;
27353 :
27354 : (void)jenv;
27355 : (void)jcls;
27356 : (void)jarg1_;
27357 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27358 0 : arg2 = (double)jarg2;
27359 0 : arg3 = (double)jarg3;
27360 : {
27361 : /* %typemap(in) (int nList, int* pListOut) */
27362 : /* check if is List */
27363 0 : if (jarg4)
27364 : {
27365 0 : arg4 = jenv->GetArrayLength(jarg4);
27366 0 : arg5 = (int*) malloc(arg4 * sizeof(int));
27367 : }
27368 : else
27369 : {
27370 0 : arg4 = 0;
27371 0 : arg5 = NULL;
27372 : }
27373 : }
27374 0 : arg6 = jarg6 ? true : false;
27375 0 : arg7 = jarg7 ? true : false;
27376 : {
27377 0 : if (!arg5) {
27378 : {
27379 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
27380 : };
27381 : }
27382 : }
27383 0 : result = (CPLErr)GDALRasterBandShadow_GetHistogram__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
27384 0 : jresult = (jint)result;
27385 : {
27386 : /* %typemap(argout) (int nList, int* pListOut) */
27387 : }
27388 : {
27389 : /* %typemap(freearg) (int nList, int* pListOut) */
27390 0 : if (arg5) {
27391 0 : jenv->SetIntArrayRegion(jarg4, 0, arg4, (jint*)arg5);
27392 0 : free((void*) arg5);
27393 : }
27394 : }
27395 0 : return jresult;
27396 : }
27397 :
27398 :
27399 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetHistogram_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jintArray jarg4) {
27400 0 : jint jresult = 0 ;
27401 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27402 : double arg2 ;
27403 : double arg3 ;
27404 : int arg4 ;
27405 0 : int *arg5 = (int *) 0 ;
27406 : CPLErr result;
27407 :
27408 : (void)jenv;
27409 : (void)jcls;
27410 : (void)jarg1_;
27411 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27412 0 : arg2 = (double)jarg2;
27413 0 : arg3 = (double)jarg3;
27414 : {
27415 : /* %typemap(in) (int nList, int* pListOut) */
27416 : /* check if is List */
27417 0 : if (jarg4)
27418 : {
27419 0 : arg4 = jenv->GetArrayLength(jarg4);
27420 0 : arg5 = (int*) malloc(arg4 * sizeof(int));
27421 : }
27422 : else
27423 : {
27424 0 : arg4 = 0;
27425 0 : arg5 = NULL;
27426 : }
27427 : }
27428 : {
27429 0 : if (!arg5) {
27430 : {
27431 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
27432 : };
27433 : }
27434 : }
27435 0 : result = (CPLErr)GDALRasterBandShadow_GetHistogram__SWIG_2(arg1,arg2,arg3,arg4,arg5);
27436 0 : jresult = (jint)result;
27437 : {
27438 : /* %typemap(argout) (int nList, int* pListOut) */
27439 : }
27440 : {
27441 : /* %typemap(freearg) (int nList, int* pListOut) */
27442 0 : if (arg5) {
27443 0 : jenv->SetIntArrayRegion(jarg4, 0, arg4, (jint*)arg5);
27444 0 : free((void*) arg5);
27445 : }
27446 : }
27447 0 : return jresult;
27448 : }
27449 :
27450 :
27451 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetHistogram_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2) {
27452 0 : jint jresult = 0 ;
27453 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27454 : int arg2 ;
27455 0 : int *arg3 = (int *) 0 ;
27456 : CPLErr result;
27457 :
27458 : (void)jenv;
27459 : (void)jcls;
27460 : (void)jarg1_;
27461 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27462 : {
27463 : /* %typemap(in) (int nList, int* pListOut) */
27464 : /* check if is List */
27465 0 : if (jarg2)
27466 : {
27467 0 : arg2 = jenv->GetArrayLength(jarg2);
27468 0 : arg3 = (int*) malloc(arg2 * sizeof(int));
27469 : }
27470 : else
27471 : {
27472 0 : arg2 = 0;
27473 0 : arg3 = NULL;
27474 : }
27475 : }
27476 : {
27477 0 : if (!arg3) {
27478 : {
27479 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
27480 : };
27481 : }
27482 : }
27483 0 : result = (CPLErr)GDALRasterBandShadow_GetHistogram__SWIG_3(arg1,arg2,arg3);
27484 0 : jresult = (jint)result;
27485 : {
27486 : /* %typemap(argout) (int nList, int* pListOut) */
27487 : }
27488 : {
27489 : /* %typemap(freearg) (int nList, int* pListOut) */
27490 0 : if (arg3) {
27491 0 : jenv->SetIntArrayRegion(jarg2, 0, arg2, (jint*)arg3);
27492 0 : free((void*) arg3);
27493 : }
27494 : }
27495 0 : return jresult;
27496 : }
27497 :
27498 :
27499 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetDefaultHistogram_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jdoubleArray jarg3, jobjectArray jarg4, jboolean jarg6, jobject jarg7) {
27500 0 : jint jresult = 0 ;
27501 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27502 0 : double *arg2 = (double *) 0 ;
27503 0 : double *arg3 = (double *) 0 ;
27504 0 : int *arg4 = (int *) 0 ;
27505 0 : int **arg5 = (int **) 0 ;
27506 : bool arg6 ;
27507 : GDALProgressFunc arg7 ;
27508 0 : void *arg8 = (void *) 0 ;
27509 : double temp2 ;
27510 : double temp3 ;
27511 0 : int nLen4 = 0 ;
27512 0 : int *pBuf4 = NULL ;
27513 : CPLErr result;
27514 :
27515 : (void)jenv;
27516 : (void)jcls;
27517 : JavaProgressData sProgressInfo;
27518 0 : sProgressInfo.jenv = jenv;
27519 0 : sProgressInfo.pJavaCallback = NULL;
27520 : (void)jarg1_;
27521 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27522 : {
27523 0 : if (!jarg2) {
27524 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27525 0 : return 0;
27526 : }
27527 0 : if (jenv->GetArrayLength(jarg2) == 0) {
27528 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27529 0 : return 0;
27530 : }
27531 0 : temp2 = (double)0;
27532 0 : arg2 = &temp2;
27533 : }
27534 : {
27535 0 : if (!jarg3) {
27536 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27537 0 : return 0;
27538 : }
27539 0 : if (jenv->GetArrayLength(jarg3) == 0) {
27540 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27541 0 : return 0;
27542 : }
27543 0 : temp3 = (double)0;
27544 0 : arg3 = &temp3;
27545 : }
27546 : {
27547 : /* %typemap(in) (int* pnList, int** ppListOut) */
27548 0 : arg4 = &nLen4;
27549 0 : arg5 = &pBuf4;
27550 : }
27551 0 : arg6 = jarg6 ? true : false;
27552 : {
27553 0 : if ( jarg7 != 0 ) {
27554 0 : sProgressInfo.pJavaCallback = jarg7;
27555 0 : arg7 = JavaProgressProxy;
27556 0 : arg8 = &sProgressInfo;
27557 : }
27558 : else
27559 : {
27560 0 : arg7 = NULL;
27561 0 : arg8 = NULL;
27562 : }
27563 : }
27564 0 : result = (CPLErr)GDALRasterBandShadow_GetDefaultHistogram__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
27565 0 : jresult = (jint)result;
27566 : {
27567 0 : jdouble jvalue = (jdouble)temp2;
27568 0 : jenv->SetDoubleArrayRegion(jarg2, 0, 1, &jvalue);
27569 : }
27570 : {
27571 0 : jdouble jvalue = (jdouble)temp3;
27572 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
27573 : }
27574 : {
27575 : /* %typemap(argout) (int* pnList, int** ppListOut) */
27576 0 : if(jarg4 && jenv->GetArrayLength(jarg4) >= 1)
27577 : {
27578 0 : jintArray intArray = jenv->NewIntArray(nLen4);
27579 0 : jenv->SetIntArrayRegion(intArray, (jsize)0, (jsize)nLen4, (jint*)pBuf4);
27580 0 : jenv->SetObjectArrayElement(jarg4,0,intArray);
27581 0 : jenv->DeleteLocalRef(intArray);
27582 : }
27583 0 : CPLFree(pBuf4);
27584 : }
27585 :
27586 :
27587 : {
27588 : /* %typemap(freearg) (int* pnList, int** ppListOut) */
27589 : }
27590 0 : return jresult;
27591 : }
27592 :
27593 :
27594 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetDefaultHistogram_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jdoubleArray jarg3, jobjectArray jarg4, jboolean jarg6) {
27595 0 : jint jresult = 0 ;
27596 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27597 0 : double *arg2 = (double *) 0 ;
27598 0 : double *arg3 = (double *) 0 ;
27599 0 : int *arg4 = (int *) 0 ;
27600 0 : int **arg5 = (int **) 0 ;
27601 : bool arg6 ;
27602 : double temp2 ;
27603 : double temp3 ;
27604 0 : int nLen4 = 0 ;
27605 0 : int *pBuf4 = NULL ;
27606 : CPLErr result;
27607 :
27608 : (void)jenv;
27609 : (void)jcls;
27610 : (void)jarg1_;
27611 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27612 : {
27613 0 : if (!jarg2) {
27614 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27615 0 : return 0;
27616 : }
27617 0 : if (jenv->GetArrayLength(jarg2) == 0) {
27618 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27619 0 : return 0;
27620 : }
27621 0 : temp2 = (double)0;
27622 0 : arg2 = &temp2;
27623 : }
27624 : {
27625 0 : if (!jarg3) {
27626 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27627 0 : return 0;
27628 : }
27629 0 : if (jenv->GetArrayLength(jarg3) == 0) {
27630 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27631 0 : return 0;
27632 : }
27633 0 : temp3 = (double)0;
27634 0 : arg3 = &temp3;
27635 : }
27636 : {
27637 : /* %typemap(in) (int* pnList, int** ppListOut) */
27638 0 : arg4 = &nLen4;
27639 0 : arg5 = &pBuf4;
27640 : }
27641 0 : arg6 = jarg6 ? true : false;
27642 0 : result = (CPLErr)GDALRasterBandShadow_GetDefaultHistogram__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
27643 0 : jresult = (jint)result;
27644 : {
27645 0 : jdouble jvalue = (jdouble)temp2;
27646 0 : jenv->SetDoubleArrayRegion(jarg2, 0, 1, &jvalue);
27647 : }
27648 : {
27649 0 : jdouble jvalue = (jdouble)temp3;
27650 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
27651 : }
27652 : {
27653 : /* %typemap(argout) (int* pnList, int** ppListOut) */
27654 0 : if(jarg4 && jenv->GetArrayLength(jarg4) >= 1)
27655 : {
27656 0 : jintArray intArray = jenv->NewIntArray(nLen4);
27657 0 : jenv->SetIntArrayRegion(intArray, (jsize)0, (jsize)nLen4, (jint*)pBuf4);
27658 0 : jenv->SetObjectArrayElement(jarg4,0,intArray);
27659 0 : jenv->DeleteLocalRef(intArray);
27660 : }
27661 0 : CPLFree(pBuf4);
27662 : }
27663 :
27664 :
27665 : {
27666 : /* %typemap(freearg) (int* pnList, int** ppListOut) */
27667 : }
27668 0 : return jresult;
27669 : }
27670 :
27671 :
27672 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Band_1GetDefaultHistogram_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jdoubleArray jarg3, jobjectArray jarg4) {
27673 0 : jint jresult = 0 ;
27674 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
27675 0 : double *arg2 = (double *) 0 ;
27676 0 : double *arg3 = (double *) 0 ;
27677 0 : int *arg4 = (int *) 0 ;
27678 0 : int **arg5 = (int **) 0 ;
27679 : double temp2 ;
27680 : double temp3 ;
27681 0 : int nLen4 = 0 ;
27682 0 : int *pBuf4 = NULL ;
27683 : CPLErr result;
27684 :
27685 : (void)jenv;
27686 : (void)jcls;
27687 : (void)jarg1_;
27688 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
27689 : {
27690 0 : if (!jarg2) {
27691 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27692 0 : return 0;
27693 : }
27694 0 : if (jenv->GetArrayLength(jarg2) == 0) {
27695 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27696 0 : return 0;
27697 : }
27698 0 : temp2 = (double)0;
27699 0 : arg2 = &temp2;
27700 : }
27701 : {
27702 0 : if (!jarg3) {
27703 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
27704 0 : return 0;
27705 : }
27706 0 : if (jenv->GetArrayLength(jarg3) == 0) {
27707 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
27708 0 : return 0;
27709 : }
27710 0 : temp3 = (double)0;
27711 0 : arg3 = &temp3;
27712 : }
27713 : {
27714 : /* %typemap(in) (int* pnList, int** ppListOut) */
27715 0 : arg4 = &nLen4;
27716 0 : arg5 = &pBuf4;
27717 : }
27718 0 : result = (CPLErr)GDALRasterBandShadow_GetDefaultHistogram__SWIG_0(arg1,arg2,arg3,arg4,arg5);
27719 0 : jresult = (jint)result;
27720 : {
27721 0 : jdouble jvalue = (jdouble)temp2;
27722 0 : jenv->SetDoubleArrayRegion(jarg2, 0, 1, &jvalue);
27723 : }
27724 : {
27725 0 : jdouble jvalue = (jdouble)temp3;
27726 0 : jenv->SetDoubleArrayRegion(jarg3, 0, 1, &jvalue);
27727 : }
27728 : {
27729 : /* %typemap(argout) (int* pnList, int** ppListOut) */
27730 0 : if(jarg4 && jenv->GetArrayLength(jarg4) >= 1)
27731 : {
27732 0 : jintArray intArray = jenv->NewIntArray(nLen4);
27733 0 : jenv->SetIntArrayRegion(intArray, (jsize)0, (jsize)nLen4, (jint*)pBuf4);
27734 0 : jenv->SetObjectArrayElement(jarg4,0,intArray);
27735 0 : jenv->DeleteLocalRef(intArray);
27736 : }
27737 0 : CPLFree(pBuf4);
27738 : }
27739 :
27740 :
27741 : {
27742 : /* %typemap(freearg) (int* pnList, int** ppListOut) */
27743 : }
27744 0 : return jresult;
27745 : }
27746 :
27747 :
27748 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1ColorTable_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jint jarg1) {
27749 0 : jlong jresult = 0 ;
27750 : GDALPaletteInterp arg1 ;
27751 0 : GDALColorTableShadow *result = 0 ;
27752 :
27753 : (void)jenv;
27754 : (void)jcls;
27755 0 : arg1 = (GDALPaletteInterp)jarg1;
27756 0 : result = (GDALColorTableShadow *)new_GDALColorTableShadow__SWIG_0(arg1);
27757 0 : *(GDALColorTableShadow **)&jresult = result;
27758 0 : return jresult;
27759 : }
27760 :
27761 :
27762 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1ColorTable_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
27763 0 : jlong jresult = 0 ;
27764 0 : GDALColorTableShadow *result = 0 ;
27765 :
27766 : (void)jenv;
27767 : (void)jcls;
27768 0 : result = (GDALColorTableShadow *)new_GDALColorTableShadow__SWIG_0();
27769 0 : *(GDALColorTableShadow **)&jresult = result;
27770 0 : return jresult;
27771 : }
27772 :
27773 :
27774 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1ColorTable(JNIEnv *jenv, jclass jcls, jlong jarg1) {
27775 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27776 :
27777 : (void)jenv;
27778 : (void)jcls;
27779 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27780 0 : delete_GDALColorTableShadow(arg1);
27781 0 : }
27782 :
27783 :
27784 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1Clone(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
27785 0 : jlong jresult = 0 ;
27786 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27787 0 : GDALColorTableShadow *result = 0 ;
27788 :
27789 : (void)jenv;
27790 : (void)jcls;
27791 : (void)jarg1_;
27792 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27793 0 : result = (GDALColorTableShadow *)GDALColorTableShadow_Clone(arg1);
27794 0 : *(GDALColorTableShadow **)&jresult = result;
27795 0 : return jresult;
27796 : }
27797 :
27798 :
27799 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1GetPaletteInterpretation(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
27800 0 : jint jresult = 0 ;
27801 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27802 : GDALPaletteInterp result;
27803 :
27804 : (void)jenv;
27805 : (void)jcls;
27806 : (void)jarg1_;
27807 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27808 0 : result = (GDALPaletteInterp)GDALColorTableShadow_GetPaletteInterpretation(arg1);
27809 0 : jresult = (jint)result;
27810 0 : return jresult;
27811 : }
27812 :
27813 :
27814 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1GetCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
27815 0 : jint jresult = 0 ;
27816 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27817 : int result;
27818 :
27819 : (void)jenv;
27820 : (void)jcls;
27821 : (void)jarg1_;
27822 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27823 0 : result = (int)GDALColorTableShadow_GetColorEntryCount(arg1);
27824 0 : jresult = (jint)result;
27825 0 : return jresult;
27826 : }
27827 :
27828 :
27829 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1GetColorEntry(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
27830 0 : jobject jresult = 0 ;
27831 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27832 : int arg2 ;
27833 0 : GDALColorEntry *result = 0 ;
27834 :
27835 : (void)jenv;
27836 : (void)jcls;
27837 : (void)jarg1_;
27838 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27839 0 : arg2 = (int)jarg2;
27840 0 : result = (GDALColorEntry *)GDALColorTableShadow_GetColorEntry(arg1,arg2);
27841 : {
27842 : /* %typemap(out) (GDALColorEntry *) */
27843 0 : const jclass Color = jenv->FindClass("java/awt/Color");
27844 0 : const jmethodID ccon = jenv->GetMethodID(Color, "<init>",
27845 : "(IIII)V");
27846 0 : jresult = jenv->NewObject(Color, ccon, result->c1, result->c2, result->c3, result->c4);
27847 : }
27848 0 : return jresult;
27849 : }
27850 :
27851 :
27852 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1SetColorEntry(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3) {
27853 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27854 : int arg2 ;
27855 0 : GDALColorEntry *arg3 = (GDALColorEntry *) 0 ;
27856 : GDALColorEntry tmp3 ;
27857 :
27858 : (void)jenv;
27859 : (void)jcls;
27860 : (void)jarg1_;
27861 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27862 0 : arg2 = (int)jarg2;
27863 : {
27864 : /* %typemap(in) (GDALColorEntry *) */
27865 0 : arg3 = NULL;
27866 0 : if (jarg3 == NULL)
27867 : {
27868 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer.");
27869 0 : return ;
27870 : }
27871 0 : float *colorptr = 0;
27872 0 : const jclass Color = jenv->FindClass("java/awt/Color");
27873 0 : const jmethodID colors = jenv->GetMethodID(Color, "getRGBComponents",
27874 : "([F)[F");
27875 :
27876 0 : jfloatArray colorArr = jenv->NewFloatArray(4);
27877 0 : colorArr = (jfloatArray)jenv->CallObjectMethod(jarg3, colors, colorArr);
27878 :
27879 0 : colorptr = (float *)jenv->GetFloatArrayElements(colorArr, 0);
27880 0 : tmp3.c1 = (short)(colorptr[0] * 255);
27881 0 : tmp3.c2 = (short)(colorptr[1] * 255);
27882 0 : tmp3.c3 = (short)(colorptr[2] * 255);
27883 0 : tmp3.c4 = (short)(colorptr[3] * 255);
27884 : /*printf( " %d, %d, %d, %d\n",
27885 : tmp3.c1, tmp3.c2, tmp3.c3, tmp3.c4 );*/
27886 0 : arg3 = &tmp3;
27887 : }
27888 0 : GDALColorTableShadow_SetColorEntry(arg1,arg2,(GDALColorEntry const *)arg3);
27889 : }
27890 :
27891 :
27892 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ColorTable_1CreateColorRamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobject jarg3, jint jarg4, jobject jarg5) {
27893 0 : GDALColorTableShadow *arg1 = (GDALColorTableShadow *) 0 ;
27894 : int arg2 ;
27895 0 : GDALColorEntry *arg3 = (GDALColorEntry *) 0 ;
27896 : int arg4 ;
27897 0 : GDALColorEntry *arg5 = (GDALColorEntry *) 0 ;
27898 : GDALColorEntry tmp3 ;
27899 : GDALColorEntry tmp5 ;
27900 :
27901 : (void)jenv;
27902 : (void)jcls;
27903 : (void)jarg1_;
27904 0 : arg1 = *(GDALColorTableShadow **)&jarg1;
27905 0 : arg2 = (int)jarg2;
27906 : {
27907 : /* %typemap(in) (GDALColorEntry *) */
27908 0 : arg3 = NULL;
27909 0 : if (jarg3 == NULL)
27910 : {
27911 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer.");
27912 0 : return ;
27913 : }
27914 0 : float *colorptr = 0;
27915 0 : const jclass Color = jenv->FindClass("java/awt/Color");
27916 0 : const jmethodID colors = jenv->GetMethodID(Color, "getRGBComponents",
27917 : "([F)[F");
27918 :
27919 0 : jfloatArray colorArr = jenv->NewFloatArray(4);
27920 0 : colorArr = (jfloatArray)jenv->CallObjectMethod(jarg3, colors, colorArr);
27921 :
27922 0 : colorptr = (float *)jenv->GetFloatArrayElements(colorArr, 0);
27923 0 : tmp3.c1 = (short)(colorptr[0] * 255);
27924 0 : tmp3.c2 = (short)(colorptr[1] * 255);
27925 0 : tmp3.c3 = (short)(colorptr[2] * 255);
27926 0 : tmp3.c4 = (short)(colorptr[3] * 255);
27927 : /*printf( " %d, %d, %d, %d\n",
27928 : tmp3.c1, tmp3.c2, tmp3.c3, tmp3.c4 );*/
27929 0 : arg3 = &tmp3;
27930 : }
27931 0 : arg4 = (int)jarg4;
27932 : {
27933 : /* %typemap(in) (GDALColorEntry *) */
27934 0 : arg5 = NULL;
27935 0 : if (jarg5 == NULL)
27936 : {
27937 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer.");
27938 0 : return ;
27939 : }
27940 0 : float *colorptr = 0;
27941 0 : const jclass Color = jenv->FindClass("java/awt/Color");
27942 0 : const jmethodID colors = jenv->GetMethodID(Color, "getRGBComponents",
27943 : "([F)[F");
27944 :
27945 0 : jfloatArray colorArr = jenv->NewFloatArray(4);
27946 0 : colorArr = (jfloatArray)jenv->CallObjectMethod(jarg5, colors, colorArr);
27947 :
27948 0 : colorptr = (float *)jenv->GetFloatArrayElements(colorArr, 0);
27949 0 : tmp5.c1 = (short)(colorptr[0] * 255);
27950 0 : tmp5.c2 = (short)(colorptr[1] * 255);
27951 0 : tmp5.c3 = (short)(colorptr[2] * 255);
27952 0 : tmp5.c4 = (short)(colorptr[3] * 255);
27953 : /*printf( " %d, %d, %d, %d\n",
27954 : tmp5.c1, tmp5.c2, tmp5.c3, tmp5.c4 );*/
27955 0 : arg5 = &tmp5;
27956 : }
27957 0 : GDALColorTableShadow_CreateColorRamp(arg1,arg2,(GDALColorEntry const *)arg3,arg4,(GDALColorEntry const *)arg5);
27958 : }
27959 :
27960 :
27961 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1SubdatasetInfo(JNIEnv *jenv, jclass jcls, jlong jarg1) {
27962 0 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
27963 :
27964 : (void)jenv;
27965 : (void)jcls;
27966 0 : arg1 = *(GDALSubdatasetInfoShadow **)&jarg1;
27967 0 : delete_GDALSubdatasetInfoShadow(arg1);
27968 0 : }
27969 :
27970 :
27971 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_SubdatasetInfo_1GetPathComponent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
27972 0 : jstring jresult = 0 ;
27973 0 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
27974 0 : retStringAndCPLFree *result = 0 ;
27975 :
27976 : (void)jenv;
27977 : (void)jcls;
27978 0 : arg1 = *(GDALSubdatasetInfoShadow **)&jarg1;
27979 0 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_GetPathComponent(arg1);
27980 : {
27981 : /* %typemap(out) (retStringAndCPLFree*) */
27982 0 : if(result)
27983 : {
27984 0 : jresult = jenv->NewStringUTF((const char *)result);
27985 0 : CPLFree(result);
27986 : }
27987 : }
27988 0 : return jresult;
27989 : }
27990 :
27991 :
27992 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_SubdatasetInfo_1GetSubdatasetComponent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
27993 0 : jstring jresult = 0 ;
27994 0 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
27995 0 : retStringAndCPLFree *result = 0 ;
27996 :
27997 : (void)jenv;
27998 : (void)jcls;
27999 0 : arg1 = *(GDALSubdatasetInfoShadow **)&jarg1;
28000 0 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_GetSubdatasetComponent(arg1);
28001 : {
28002 : /* %typemap(out) (retStringAndCPLFree*) */
28003 0 : if(result)
28004 : {
28005 0 : jresult = jenv->NewStringUTF((const char *)result);
28006 0 : CPLFree(result);
28007 : }
28008 : }
28009 0 : return jresult;
28010 : }
28011 :
28012 :
28013 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_SubdatasetInfo_1ModifyPathComponent(JNIEnv *jenv, jclass jcls, jlong jarg1, jstring jarg2) {
28014 0 : jstring jresult = 0 ;
28015 0 : GDALSubdatasetInfoShadow *arg1 = (GDALSubdatasetInfoShadow *) 0 ;
28016 0 : char *arg2 = (char *) 0 ;
28017 0 : retStringAndCPLFree *result = 0 ;
28018 :
28019 : (void)jenv;
28020 : (void)jcls;
28021 0 : arg1 = *(GDALSubdatasetInfoShadow **)&jarg1;
28022 0 : arg2 = 0;
28023 0 : if (jarg2) {
28024 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28025 0 : if (!arg2) return 0;
28026 : }
28027 0 : result = (retStringAndCPLFree *)GDALSubdatasetInfoShadow_ModifyPathComponent(arg1,(char const *)arg2);
28028 : {
28029 : /* %typemap(out) (retStringAndCPLFree*) */
28030 0 : if(result)
28031 : {
28032 0 : jresult = jenv->NewStringUTF((const char *)result);
28033 0 : CPLFree(result);
28034 : }
28035 : }
28036 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
28037 0 : return jresult;
28038 : }
28039 :
28040 :
28041 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_GetSubdatasetInfo(JNIEnv *jenv, jclass jcls, jstring jarg1) {
28042 0 : jlong jresult = 0 ;
28043 0 : char *arg1 = (char *) 0 ;
28044 0 : GDALSubdatasetInfoShadow *result = 0 ;
28045 :
28046 : (void)jenv;
28047 : (void)jcls;
28048 0 : arg1 = 0;
28049 0 : if (jarg1) {
28050 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
28051 0 : if (!arg1) return 0;
28052 : }
28053 0 : result = (GDALSubdatasetInfoShadow *)GetSubdatasetInfo((char const *)arg1);
28054 0 : *(GDALSubdatasetInfoShadow **)&jresult = result;
28055 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
28056 0 : return jresult;
28057 : }
28058 :
28059 :
28060 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1Relationship(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3, jint jarg4) {
28061 0 : jlong jresult = 0 ;
28062 0 : char *arg1 = (char *) 0 ;
28063 0 : char *arg2 = (char *) 0 ;
28064 0 : char *arg3 = (char *) 0 ;
28065 : GDALRelationshipCardinality arg4 ;
28066 0 : GDALRelationshipShadow *result = 0 ;
28067 :
28068 : (void)jenv;
28069 : (void)jcls;
28070 0 : arg1 = 0;
28071 0 : if (jarg1) {
28072 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
28073 0 : if (!arg1) return 0;
28074 : }
28075 0 : arg2 = 0;
28076 0 : if (jarg2) {
28077 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28078 0 : if (!arg2) return 0;
28079 : }
28080 0 : arg3 = 0;
28081 0 : if (jarg3) {
28082 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
28083 0 : if (!arg3) return 0;
28084 : }
28085 0 : arg4 = (GDALRelationshipCardinality)jarg4;
28086 : {
28087 0 : if (!arg1) {
28088 : {
28089 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28090 : };
28091 : }
28092 : }
28093 0 : result = (GDALRelationshipShadow *)new_GDALRelationshipShadow((char const *)arg1,(char const *)arg2,(char const *)arg3,arg4);
28094 0 : *(GDALRelationshipShadow **)&jresult = result;
28095 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
28096 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
28097 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
28098 0 : return jresult;
28099 : }
28100 :
28101 :
28102 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Relationship(JNIEnv *jenv, jclass jcls, jlong jarg1) {
28103 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28104 :
28105 : (void)jenv;
28106 : (void)jcls;
28107 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28108 0 : delete_GDALRelationshipShadow(arg1);
28109 0 : }
28110 :
28111 :
28112 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28113 0 : jstring jresult = 0 ;
28114 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28115 0 : char *result = 0 ;
28116 :
28117 : (void)jenv;
28118 : (void)jcls;
28119 : (void)jarg1_;
28120 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28121 0 : result = (char *)GDALRelationshipShadow_GetName(arg1);
28122 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28123 0 : return jresult;
28124 : }
28125 :
28126 :
28127 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetCardinality(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28128 0 : jint jresult = 0 ;
28129 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28130 : GDALRelationshipCardinality result;
28131 :
28132 : (void)jenv;
28133 : (void)jcls;
28134 : (void)jarg1_;
28135 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28136 0 : result = (GDALRelationshipCardinality)GDALRelationshipShadow_GetCardinality(arg1);
28137 0 : jresult = (jint)result;
28138 0 : return jresult;
28139 : }
28140 :
28141 :
28142 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetLeftTableName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28143 0 : jstring jresult = 0 ;
28144 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28145 0 : char *result = 0 ;
28146 :
28147 : (void)jenv;
28148 : (void)jcls;
28149 : (void)jarg1_;
28150 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28151 0 : result = (char *)GDALRelationshipShadow_GetLeftTableName(arg1);
28152 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28153 0 : return jresult;
28154 : }
28155 :
28156 :
28157 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetRightTableName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28158 0 : jstring jresult = 0 ;
28159 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28160 0 : char *result = 0 ;
28161 :
28162 : (void)jenv;
28163 : (void)jcls;
28164 : (void)jarg1_;
28165 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28166 0 : result = (char *)GDALRelationshipShadow_GetRightTableName(arg1);
28167 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28168 0 : return jresult;
28169 : }
28170 :
28171 :
28172 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetMappingTableName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28173 0 : jstring jresult = 0 ;
28174 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28175 0 : char *result = 0 ;
28176 :
28177 : (void)jenv;
28178 : (void)jcls;
28179 : (void)jarg1_;
28180 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28181 0 : result = (char *)GDALRelationshipShadow_GetMappingTableName(arg1);
28182 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28183 0 : return jresult;
28184 : }
28185 :
28186 :
28187 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetMappingTableName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
28188 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28189 0 : char *arg2 = (char *) 0 ;
28190 :
28191 : (void)jenv;
28192 : (void)jcls;
28193 : (void)jarg1_;
28194 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28195 : {
28196 : /* %typemap(in) (tostring argin) */
28197 0 : if (jarg2)
28198 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28199 : }
28200 0 : GDALRelationshipShadow_SetMappingTableName(arg1,(char const *)arg2);
28201 : {
28202 : /* %typemap(freearg) (tostring argin) */
28203 0 : if (jarg2)
28204 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
28205 : }
28206 0 : }
28207 :
28208 :
28209 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetLeftTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28210 0 : jobject jresult = 0 ;
28211 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28212 0 : char **result = 0 ;
28213 :
28214 : (void)jenv;
28215 : (void)jcls;
28216 : (void)jarg1_;
28217 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28218 0 : result = (char **)GDALRelationshipShadow_GetLeftTableFields(arg1);
28219 : {
28220 : /* %typemap(out) char **CSL */
28221 0 : char **stringarray = result;
28222 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28223 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
28224 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
28225 :
28226 0 : jresult = jenv->NewObject(vector, constructor);
28227 0 : if ( stringarray != NULL ) {
28228 0 : while(*stringarray != NULL) {
28229 : /*printf("working on string %s\n", *stringarray);*/
28230 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
28231 0 : jenv->CallBooleanMethod(jresult, add, value);
28232 0 : jenv->DeleteLocalRef(value);
28233 0 : stringarray++;
28234 : }
28235 : }
28236 0 : CSLDestroy(result);
28237 : }
28238 0 : return jresult;
28239 : }
28240 :
28241 :
28242 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetRightTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28243 0 : jobject jresult = 0 ;
28244 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28245 0 : char **result = 0 ;
28246 :
28247 : (void)jenv;
28248 : (void)jcls;
28249 : (void)jarg1_;
28250 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28251 0 : result = (char **)GDALRelationshipShadow_GetRightTableFields(arg1);
28252 : {
28253 : /* %typemap(out) char **CSL */
28254 0 : char **stringarray = result;
28255 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28256 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
28257 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
28258 :
28259 0 : jresult = jenv->NewObject(vector, constructor);
28260 0 : if ( stringarray != NULL ) {
28261 0 : while(*stringarray != NULL) {
28262 : /*printf("working on string %s\n", *stringarray);*/
28263 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
28264 0 : jenv->CallBooleanMethod(jresult, add, value);
28265 0 : jenv->DeleteLocalRef(value);
28266 0 : stringarray++;
28267 : }
28268 : }
28269 0 : CSLDestroy(result);
28270 : }
28271 0 : return jresult;
28272 : }
28273 :
28274 :
28275 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetLeftTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
28276 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28277 0 : char **arg2 = (char **) 0 ;
28278 :
28279 : (void)jenv;
28280 : (void)jcls;
28281 : (void)jarg1_;
28282 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28283 : {
28284 : /* %typemap(in) char **options */
28285 0 : arg2 = NULL;
28286 0 : if(jarg2 != 0) {
28287 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28288 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
28289 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
28290 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
28291 : "()Ljava/util/Enumeration;");
28292 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
28293 : "hasMoreElements", "()Z");
28294 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
28295 : "nextElement", "()Ljava/lang/Object;");
28296 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
28297 0 : hasMoreElements == NULL || getNextElement == NULL) {
28298 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
28299 0 : return ;
28300 : }
28301 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
28302 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
28303 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
28304 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
28305 : {
28306 0 : CSLDestroy(arg2);
28307 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
28308 0 : return ;
28309 : }
28310 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
28311 0 : arg2 = CSLAddString(arg2, valptr);
28312 0 : jenv->ReleaseStringUTFChars(value, valptr);
28313 : }
28314 : }
28315 : }
28316 0 : GDALRelationshipShadow_SetLeftTableFields(arg1,arg2);
28317 : {
28318 : /* %typemap(freearg) char **options */
28319 0 : CSLDestroy( arg2 );
28320 : }
28321 : }
28322 :
28323 :
28324 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetRightTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
28325 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28326 0 : char **arg2 = (char **) 0 ;
28327 :
28328 : (void)jenv;
28329 : (void)jcls;
28330 : (void)jarg1_;
28331 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28332 : {
28333 : /* %typemap(in) char **options */
28334 0 : arg2 = NULL;
28335 0 : if(jarg2 != 0) {
28336 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28337 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
28338 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
28339 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
28340 : "()Ljava/util/Enumeration;");
28341 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
28342 : "hasMoreElements", "()Z");
28343 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
28344 : "nextElement", "()Ljava/lang/Object;");
28345 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
28346 0 : hasMoreElements == NULL || getNextElement == NULL) {
28347 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
28348 0 : return ;
28349 : }
28350 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
28351 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
28352 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
28353 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
28354 : {
28355 0 : CSLDestroy(arg2);
28356 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
28357 0 : return ;
28358 : }
28359 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
28360 0 : arg2 = CSLAddString(arg2, valptr);
28361 0 : jenv->ReleaseStringUTFChars(value, valptr);
28362 : }
28363 : }
28364 : }
28365 0 : GDALRelationshipShadow_SetRightTableFields(arg1,arg2);
28366 : {
28367 : /* %typemap(freearg) char **options */
28368 0 : CSLDestroy( arg2 );
28369 : }
28370 : }
28371 :
28372 :
28373 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetLeftMappingTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28374 0 : jobject jresult = 0 ;
28375 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28376 0 : char **result = 0 ;
28377 :
28378 : (void)jenv;
28379 : (void)jcls;
28380 : (void)jarg1_;
28381 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28382 0 : result = (char **)GDALRelationshipShadow_GetLeftMappingTableFields(arg1);
28383 : {
28384 : /* %typemap(out) char **CSL */
28385 0 : char **stringarray = result;
28386 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28387 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
28388 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
28389 :
28390 0 : jresult = jenv->NewObject(vector, constructor);
28391 0 : if ( stringarray != NULL ) {
28392 0 : while(*stringarray != NULL) {
28393 : /*printf("working on string %s\n", *stringarray);*/
28394 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
28395 0 : jenv->CallBooleanMethod(jresult, add, value);
28396 0 : jenv->DeleteLocalRef(value);
28397 0 : stringarray++;
28398 : }
28399 : }
28400 0 : CSLDestroy(result);
28401 : }
28402 0 : return jresult;
28403 : }
28404 :
28405 :
28406 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetRightMappingTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28407 0 : jobject jresult = 0 ;
28408 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28409 0 : char **result = 0 ;
28410 :
28411 : (void)jenv;
28412 : (void)jcls;
28413 : (void)jarg1_;
28414 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28415 0 : result = (char **)GDALRelationshipShadow_GetRightMappingTableFields(arg1);
28416 : {
28417 : /* %typemap(out) char **CSL */
28418 0 : char **stringarray = result;
28419 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28420 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
28421 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
28422 :
28423 0 : jresult = jenv->NewObject(vector, constructor);
28424 0 : if ( stringarray != NULL ) {
28425 0 : while(*stringarray != NULL) {
28426 : /*printf("working on string %s\n", *stringarray);*/
28427 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
28428 0 : jenv->CallBooleanMethod(jresult, add, value);
28429 0 : jenv->DeleteLocalRef(value);
28430 0 : stringarray++;
28431 : }
28432 : }
28433 0 : CSLDestroy(result);
28434 : }
28435 0 : return jresult;
28436 : }
28437 :
28438 :
28439 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetLeftMappingTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
28440 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28441 0 : char **arg2 = (char **) 0 ;
28442 :
28443 : (void)jenv;
28444 : (void)jcls;
28445 : (void)jarg1_;
28446 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28447 : {
28448 : /* %typemap(in) char **options */
28449 0 : arg2 = NULL;
28450 0 : if(jarg2 != 0) {
28451 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28452 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
28453 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
28454 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
28455 : "()Ljava/util/Enumeration;");
28456 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
28457 : "hasMoreElements", "()Z");
28458 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
28459 : "nextElement", "()Ljava/lang/Object;");
28460 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
28461 0 : hasMoreElements == NULL || getNextElement == NULL) {
28462 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
28463 0 : return ;
28464 : }
28465 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
28466 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
28467 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
28468 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
28469 : {
28470 0 : CSLDestroy(arg2);
28471 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
28472 0 : return ;
28473 : }
28474 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
28475 0 : arg2 = CSLAddString(arg2, valptr);
28476 0 : jenv->ReleaseStringUTFChars(value, valptr);
28477 : }
28478 : }
28479 : }
28480 0 : GDALRelationshipShadow_SetLeftMappingTableFields(arg1,arg2);
28481 : {
28482 : /* %typemap(freearg) char **options */
28483 0 : CSLDestroy( arg2 );
28484 : }
28485 : }
28486 :
28487 :
28488 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetRightMappingTableFields(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
28489 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28490 0 : char **arg2 = (char **) 0 ;
28491 :
28492 : (void)jenv;
28493 : (void)jcls;
28494 : (void)jarg1_;
28495 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28496 : {
28497 : /* %typemap(in) char **options */
28498 0 : arg2 = NULL;
28499 0 : if(jarg2 != 0) {
28500 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28501 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
28502 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
28503 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
28504 : "()Ljava/util/Enumeration;");
28505 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
28506 : "hasMoreElements", "()Z");
28507 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
28508 : "nextElement", "()Ljava/lang/Object;");
28509 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
28510 0 : hasMoreElements == NULL || getNextElement == NULL) {
28511 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
28512 0 : return ;
28513 : }
28514 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
28515 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
28516 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
28517 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
28518 : {
28519 0 : CSLDestroy(arg2);
28520 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
28521 0 : return ;
28522 : }
28523 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
28524 0 : arg2 = CSLAddString(arg2, valptr);
28525 0 : jenv->ReleaseStringUTFChars(value, valptr);
28526 : }
28527 : }
28528 : }
28529 0 : GDALRelationshipShadow_SetRightMappingTableFields(arg1,arg2);
28530 : {
28531 : /* %typemap(freearg) char **options */
28532 0 : CSLDestroy( arg2 );
28533 : }
28534 : }
28535 :
28536 :
28537 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28538 0 : jint jresult = 0 ;
28539 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28540 : GDALRelationshipType result;
28541 :
28542 : (void)jenv;
28543 : (void)jcls;
28544 : (void)jarg1_;
28545 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28546 0 : result = (GDALRelationshipType)GDALRelationshipShadow_GetType(arg1);
28547 0 : jresult = (jint)result;
28548 0 : return jresult;
28549 : }
28550 :
28551 :
28552 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
28553 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28554 : GDALRelationshipType arg2 ;
28555 :
28556 : (void)jenv;
28557 : (void)jcls;
28558 : (void)jarg1_;
28559 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28560 0 : arg2 = (GDALRelationshipType)jarg2;
28561 0 : GDALRelationshipShadow_SetType(arg1,arg2);
28562 0 : }
28563 :
28564 :
28565 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetForwardPathLabel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28566 0 : jstring jresult = 0 ;
28567 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28568 0 : char *result = 0 ;
28569 :
28570 : (void)jenv;
28571 : (void)jcls;
28572 : (void)jarg1_;
28573 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28574 0 : result = (char *)GDALRelationshipShadow_GetForwardPathLabel(arg1);
28575 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28576 0 : return jresult;
28577 : }
28578 :
28579 :
28580 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetForwardPathLabel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
28581 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28582 0 : char *arg2 = (char *) 0 ;
28583 :
28584 : (void)jenv;
28585 : (void)jcls;
28586 : (void)jarg1_;
28587 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28588 : {
28589 : /* %typemap(in) (tostring argin) */
28590 0 : if (jarg2)
28591 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28592 : }
28593 0 : GDALRelationshipShadow_SetForwardPathLabel(arg1,(char const *)arg2);
28594 : {
28595 : /* %typemap(freearg) (tostring argin) */
28596 0 : if (jarg2)
28597 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
28598 : }
28599 0 : }
28600 :
28601 :
28602 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetBackwardPathLabel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28603 0 : jstring jresult = 0 ;
28604 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28605 0 : char *result = 0 ;
28606 :
28607 : (void)jenv;
28608 : (void)jcls;
28609 : (void)jarg1_;
28610 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28611 0 : result = (char *)GDALRelationshipShadow_GetBackwardPathLabel(arg1);
28612 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28613 0 : return jresult;
28614 : }
28615 :
28616 :
28617 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetBackwardPathLabel(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
28618 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28619 0 : char *arg2 = (char *) 0 ;
28620 :
28621 : (void)jenv;
28622 : (void)jcls;
28623 : (void)jarg1_;
28624 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28625 : {
28626 : /* %typemap(in) (tostring argin) */
28627 0 : if (jarg2)
28628 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28629 : }
28630 0 : GDALRelationshipShadow_SetBackwardPathLabel(arg1,(char const *)arg2);
28631 : {
28632 : /* %typemap(freearg) (tostring argin) */
28633 0 : if (jarg2)
28634 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
28635 : }
28636 0 : }
28637 :
28638 :
28639 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1GetRelatedTableType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
28640 0 : jstring jresult = 0 ;
28641 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28642 0 : char *result = 0 ;
28643 :
28644 : (void)jenv;
28645 : (void)jcls;
28646 : (void)jarg1_;
28647 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28648 0 : result = (char *)GDALRelationshipShadow_GetRelatedTableType(arg1);
28649 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
28650 0 : return jresult;
28651 : }
28652 :
28653 :
28654 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_Relationship_1SetRelatedTableType(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
28655 0 : GDALRelationshipShadow *arg1 = (GDALRelationshipShadow *) 0 ;
28656 0 : char *arg2 = (char *) 0 ;
28657 :
28658 : (void)jenv;
28659 : (void)jcls;
28660 : (void)jarg1_;
28661 0 : arg1 = *(GDALRelationshipShadow **)&jarg1;
28662 : {
28663 : /* %typemap(in) (tostring argin) */
28664 0 : if (jarg2)
28665 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
28666 : }
28667 0 : GDALRelationshipShadow_SetRelatedTableType(arg1,(char const *)arg2);
28668 : {
28669 : /* %typemap(freearg) (tostring argin) */
28670 0 : if (jarg2)
28671 0 : jenv->ReleaseStringUTFChars(jarg2, (char*)arg2);
28672 : }
28673 0 : }
28674 :
28675 :
28676 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ComputeMedianCutPCT_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jlong jarg5, jobject jarg5_, jobject jarg6) {
28677 0 : jint jresult = 0 ;
28678 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
28679 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
28680 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
28681 : int arg4 ;
28682 0 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
28683 : GDALProgressFunc arg6 ;
28684 0 : void *arg7 = (void *) 0 ;
28685 : int result;
28686 :
28687 : (void)jenv;
28688 : (void)jcls;
28689 : JavaProgressData sProgressInfo;
28690 0 : sProgressInfo.jenv = jenv;
28691 0 : sProgressInfo.pJavaCallback = NULL;
28692 : (void)jarg1_;
28693 : (void)jarg2_;
28694 : (void)jarg3_;
28695 : (void)jarg5_;
28696 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
28697 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
28698 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
28699 0 : arg4 = (int)jarg4;
28700 0 : arg5 = *(GDALColorTableShadow **)&jarg5;
28701 : {
28702 0 : if ( jarg6 != 0 ) {
28703 0 : sProgressInfo.pJavaCallback = jarg6;
28704 0 : arg6 = JavaProgressProxy;
28705 0 : arg7 = &sProgressInfo;
28706 : }
28707 : else
28708 : {
28709 0 : arg6 = NULL;
28710 0 : arg7 = NULL;
28711 : }
28712 : }
28713 : {
28714 0 : if (!arg1) {
28715 : {
28716 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28717 : };
28718 : }
28719 : }
28720 : {
28721 0 : if (!arg2) {
28722 : {
28723 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28724 : };
28725 : }
28726 : }
28727 : {
28728 0 : if (!arg3) {
28729 : {
28730 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28731 : };
28732 : }
28733 : }
28734 : {
28735 0 : if (!arg5) {
28736 : {
28737 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28738 : };
28739 : }
28740 : }
28741 0 : result = (int)ComputeMedianCutPCT(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
28742 0 : jresult = (jint)result;
28743 0 : return jresult;
28744 : }
28745 :
28746 :
28747 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ComputeMedianCutPCT_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jlong jarg5, jobject jarg5_) {
28748 0 : jint jresult = 0 ;
28749 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
28750 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
28751 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
28752 : int arg4 ;
28753 0 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
28754 : int result;
28755 :
28756 : (void)jenv;
28757 : (void)jcls;
28758 : (void)jarg1_;
28759 : (void)jarg2_;
28760 : (void)jarg3_;
28761 : (void)jarg5_;
28762 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
28763 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
28764 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
28765 0 : arg4 = (int)jarg4;
28766 0 : arg5 = *(GDALColorTableShadow **)&jarg5;
28767 : {
28768 0 : if (!arg1) {
28769 : {
28770 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28771 : };
28772 : }
28773 : }
28774 : {
28775 0 : if (!arg2) {
28776 : {
28777 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28778 : };
28779 : }
28780 : }
28781 : {
28782 0 : if (!arg3) {
28783 : {
28784 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28785 : };
28786 : }
28787 : }
28788 : {
28789 0 : if (!arg5) {
28790 : {
28791 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28792 : };
28793 : }
28794 : }
28795 0 : result = (int)ComputeMedianCutPCT(arg1,arg2,arg3,arg4,arg5);
28796 0 : jresult = (jint)result;
28797 0 : return jresult;
28798 : }
28799 :
28800 :
28801 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_DitherRGB2PCT_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_, jobject jarg6) {
28802 0 : jint jresult = 0 ;
28803 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
28804 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
28805 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
28806 0 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
28807 0 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
28808 : GDALProgressFunc arg6 ;
28809 0 : void *arg7 = (void *) 0 ;
28810 : int result;
28811 :
28812 : (void)jenv;
28813 : (void)jcls;
28814 : JavaProgressData sProgressInfo;
28815 0 : sProgressInfo.jenv = jenv;
28816 0 : sProgressInfo.pJavaCallback = NULL;
28817 : (void)jarg1_;
28818 : (void)jarg2_;
28819 : (void)jarg3_;
28820 : (void)jarg4_;
28821 : (void)jarg5_;
28822 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
28823 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
28824 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
28825 0 : arg4 = *(GDALRasterBandShadow **)&jarg4;
28826 0 : arg5 = *(GDALColorTableShadow **)&jarg5;
28827 : {
28828 0 : if ( jarg6 != 0 ) {
28829 0 : sProgressInfo.pJavaCallback = jarg6;
28830 0 : arg6 = JavaProgressProxy;
28831 0 : arg7 = &sProgressInfo;
28832 : }
28833 : else
28834 : {
28835 0 : arg6 = NULL;
28836 0 : arg7 = NULL;
28837 : }
28838 : }
28839 : {
28840 0 : if (!arg1) {
28841 : {
28842 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28843 : };
28844 : }
28845 : }
28846 : {
28847 0 : if (!arg2) {
28848 : {
28849 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28850 : };
28851 : }
28852 : }
28853 : {
28854 0 : if (!arg3) {
28855 : {
28856 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28857 : };
28858 : }
28859 : }
28860 : {
28861 0 : if (!arg4) {
28862 : {
28863 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28864 : };
28865 : }
28866 : }
28867 : {
28868 0 : if (!arg5) {
28869 : {
28870 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28871 : };
28872 : }
28873 : }
28874 0 : result = (int)DitherRGB2PCT(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
28875 0 : jresult = (jint)result;
28876 0 : return jresult;
28877 : }
28878 :
28879 :
28880 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_DitherRGB2PCT_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {
28881 0 : jint jresult = 0 ;
28882 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
28883 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
28884 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
28885 0 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
28886 0 : GDALColorTableShadow *arg5 = (GDALColorTableShadow *) 0 ;
28887 : int result;
28888 :
28889 : (void)jenv;
28890 : (void)jcls;
28891 : (void)jarg1_;
28892 : (void)jarg2_;
28893 : (void)jarg3_;
28894 : (void)jarg4_;
28895 : (void)jarg5_;
28896 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
28897 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
28898 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
28899 0 : arg4 = *(GDALRasterBandShadow **)&jarg4;
28900 0 : arg5 = *(GDALColorTableShadow **)&jarg5;
28901 : {
28902 0 : if (!arg1) {
28903 : {
28904 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28905 : };
28906 : }
28907 : }
28908 : {
28909 0 : if (!arg2) {
28910 : {
28911 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28912 : };
28913 : }
28914 : }
28915 : {
28916 0 : if (!arg3) {
28917 : {
28918 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28919 : };
28920 : }
28921 : }
28922 : {
28923 0 : if (!arg4) {
28924 : {
28925 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28926 : };
28927 : }
28928 : }
28929 : {
28930 0 : if (!arg5) {
28931 : {
28932 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
28933 : };
28934 : }
28935 : }
28936 0 : result = (int)DitherRGB2PCT(arg1,arg2,arg3,arg4,arg5);
28937 0 : jresult = (jint)result;
28938 0 : return jresult;
28939 : }
28940 :
28941 :
28942 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5, jdouble jarg6, jdouble jarg7, jobject jarg8, jobject jarg10) {
28943 0 : jint jresult = 0 ;
28944 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
28945 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
28946 0 : char *arg3 = (char *) 0 ;
28947 0 : char *arg4 = (char *) 0 ;
28948 : GDALResampleAlg arg5 ;
28949 : double arg6 ;
28950 : double arg7 ;
28951 : GDALProgressFunc arg8 ;
28952 0 : void *arg9 = (void *) 0 ;
28953 0 : char **arg10 = (char **) 0 ;
28954 : CPLErr result;
28955 :
28956 : (void)jenv;
28957 : (void)jcls;
28958 : JavaProgressData sProgressInfo;
28959 0 : sProgressInfo.jenv = jenv;
28960 0 : sProgressInfo.pJavaCallback = NULL;
28961 : (void)jarg1_;
28962 : (void)jarg2_;
28963 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
28964 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
28965 0 : arg3 = 0;
28966 0 : if (jarg3) {
28967 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
28968 0 : if (!arg3) return 0;
28969 : }
28970 0 : arg4 = 0;
28971 0 : if (jarg4) {
28972 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
28973 0 : if (!arg4) return 0;
28974 : }
28975 0 : arg5 = (GDALResampleAlg)jarg5;
28976 0 : arg6 = (double)jarg6;
28977 0 : arg7 = (double)jarg7;
28978 : {
28979 0 : if ( jarg8 != 0 ) {
28980 0 : sProgressInfo.pJavaCallback = jarg8;
28981 0 : arg8 = JavaProgressProxy;
28982 0 : arg9 = &sProgressInfo;
28983 : }
28984 : else
28985 : {
28986 0 : arg8 = NULL;
28987 0 : arg9 = NULL;
28988 : }
28989 : }
28990 : {
28991 : /* %typemap(in) char **options */
28992 0 : arg10 = NULL;
28993 0 : if(jarg10 != 0) {
28994 0 : const jclass vector = jenv->FindClass("java/util/Vector");
28995 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
28996 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
28997 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
28998 : "()Ljava/util/Enumeration;");
28999 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
29000 : "hasMoreElements", "()Z");
29001 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
29002 : "nextElement", "()Ljava/lang/Object;");
29003 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
29004 0 : hasMoreElements == NULL || getNextElement == NULL) {
29005 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
29006 0 : return 0;
29007 : }
29008 0 : for (jobject keys = jenv->CallObjectMethod(jarg10, elements);
29009 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
29010 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
29011 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
29012 : {
29013 0 : CSLDestroy(arg10);
29014 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
29015 0 : return 0;
29016 : }
29017 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
29018 0 : arg10 = CSLAddString(arg10, valptr);
29019 0 : jenv->ReleaseStringUTFChars(value, valptr);
29020 : }
29021 : }
29022 : }
29023 : {
29024 0 : if (!arg1) {
29025 : {
29026 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29027 : };
29028 : }
29029 : }
29030 : {
29031 0 : if (!arg2) {
29032 : {
29033 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29034 : };
29035 : }
29036 : }
29037 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
29038 0 : jresult = (jint)result;
29039 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29040 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29041 : {
29042 : /* %typemap(freearg) char **options */
29043 0 : CSLDestroy( arg10 );
29044 : }
29045 0 : return jresult;
29046 : }
29047 :
29048 :
29049 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5, jdouble jarg6, jdouble jarg7, jobject jarg8) {
29050 0 : jint jresult = 0 ;
29051 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29052 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29053 0 : char *arg3 = (char *) 0 ;
29054 0 : char *arg4 = (char *) 0 ;
29055 : GDALResampleAlg arg5 ;
29056 : double arg6 ;
29057 : double arg7 ;
29058 : GDALProgressFunc arg8 ;
29059 0 : void *arg9 = (void *) 0 ;
29060 : CPLErr result;
29061 :
29062 : (void)jenv;
29063 : (void)jcls;
29064 : JavaProgressData sProgressInfo;
29065 0 : sProgressInfo.jenv = jenv;
29066 0 : sProgressInfo.pJavaCallback = NULL;
29067 : (void)jarg1_;
29068 : (void)jarg2_;
29069 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29070 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29071 0 : arg3 = 0;
29072 0 : if (jarg3) {
29073 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29074 0 : if (!arg3) return 0;
29075 : }
29076 0 : arg4 = 0;
29077 0 : if (jarg4) {
29078 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
29079 0 : if (!arg4) return 0;
29080 : }
29081 0 : arg5 = (GDALResampleAlg)jarg5;
29082 0 : arg6 = (double)jarg6;
29083 0 : arg7 = (double)jarg7;
29084 : {
29085 0 : if ( jarg8 != 0 ) {
29086 0 : sProgressInfo.pJavaCallback = jarg8;
29087 0 : arg8 = JavaProgressProxy;
29088 0 : arg9 = &sProgressInfo;
29089 : }
29090 : else
29091 : {
29092 0 : arg8 = NULL;
29093 0 : arg9 = NULL;
29094 : }
29095 : }
29096 : {
29097 0 : if (!arg1) {
29098 : {
29099 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29100 : };
29101 : }
29102 : }
29103 : {
29104 0 : if (!arg2) {
29105 : {
29106 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29107 : };
29108 : }
29109 : }
29110 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7,arg8,arg9);
29111 0 : jresult = (jint)result;
29112 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29113 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29114 0 : return jresult;
29115 : }
29116 :
29117 :
29118 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5, jdouble jarg6, jdouble jarg7) {
29119 0 : jint jresult = 0 ;
29120 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29121 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29122 0 : char *arg3 = (char *) 0 ;
29123 0 : char *arg4 = (char *) 0 ;
29124 : GDALResampleAlg arg5 ;
29125 : double arg6 ;
29126 : double arg7 ;
29127 : CPLErr result;
29128 :
29129 : (void)jenv;
29130 : (void)jcls;
29131 : (void)jarg1_;
29132 : (void)jarg2_;
29133 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29134 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29135 0 : arg3 = 0;
29136 0 : if (jarg3) {
29137 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29138 0 : if (!arg3) return 0;
29139 : }
29140 0 : arg4 = 0;
29141 0 : if (jarg4) {
29142 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
29143 0 : if (!arg4) return 0;
29144 : }
29145 0 : arg5 = (GDALResampleAlg)jarg5;
29146 0 : arg6 = (double)jarg6;
29147 0 : arg7 = (double)jarg7;
29148 : {
29149 0 : if (!arg1) {
29150 : {
29151 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29152 : };
29153 : }
29154 : }
29155 : {
29156 0 : if (!arg2) {
29157 : {
29158 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29159 : };
29160 : }
29161 : }
29162 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
29163 0 : jresult = (jint)result;
29164 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29165 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29166 0 : return jresult;
29167 : }
29168 :
29169 :
29170 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5, jdouble jarg6) {
29171 0 : jint jresult = 0 ;
29172 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29173 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29174 0 : char *arg3 = (char *) 0 ;
29175 0 : char *arg4 = (char *) 0 ;
29176 : GDALResampleAlg arg5 ;
29177 : double arg6 ;
29178 : CPLErr result;
29179 :
29180 : (void)jenv;
29181 : (void)jcls;
29182 : (void)jarg1_;
29183 : (void)jarg2_;
29184 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29185 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29186 0 : arg3 = 0;
29187 0 : if (jarg3) {
29188 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29189 0 : if (!arg3) return 0;
29190 : }
29191 0 : arg4 = 0;
29192 0 : if (jarg4) {
29193 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
29194 0 : if (!arg4) return 0;
29195 : }
29196 0 : arg5 = (GDALResampleAlg)jarg5;
29197 0 : arg6 = (double)jarg6;
29198 : {
29199 0 : if (!arg1) {
29200 : {
29201 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29202 : };
29203 : }
29204 : }
29205 : {
29206 0 : if (!arg2) {
29207 : {
29208 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29209 : };
29210 : }
29211 : }
29212 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6);
29213 0 : jresult = (jint)result;
29214 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29215 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29216 0 : return jresult;
29217 : }
29218 :
29219 :
29220 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jint jarg5) {
29221 0 : jint jresult = 0 ;
29222 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29223 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29224 0 : char *arg3 = (char *) 0 ;
29225 0 : char *arg4 = (char *) 0 ;
29226 : GDALResampleAlg arg5 ;
29227 : CPLErr result;
29228 :
29229 : (void)jenv;
29230 : (void)jcls;
29231 : (void)jarg1_;
29232 : (void)jarg2_;
29233 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29234 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29235 0 : arg3 = 0;
29236 0 : if (jarg3) {
29237 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29238 0 : if (!arg3) return 0;
29239 : }
29240 0 : arg4 = 0;
29241 0 : if (jarg4) {
29242 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
29243 0 : if (!arg4) return 0;
29244 : }
29245 0 : arg5 = (GDALResampleAlg)jarg5;
29246 : {
29247 0 : if (!arg1) {
29248 : {
29249 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29250 : };
29251 : }
29252 : }
29253 : {
29254 0 : if (!arg2) {
29255 : {
29256 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29257 : };
29258 : }
29259 : }
29260 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
29261 0 : jresult = (jint)result;
29262 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29263 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29264 0 : return jresult;
29265 : }
29266 :
29267 :
29268 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4) {
29269 0 : jint jresult = 0 ;
29270 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29271 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29272 0 : char *arg3 = (char *) 0 ;
29273 0 : char *arg4 = (char *) 0 ;
29274 : CPLErr result;
29275 :
29276 : (void)jenv;
29277 : (void)jcls;
29278 : (void)jarg1_;
29279 : (void)jarg2_;
29280 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29281 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29282 0 : arg3 = 0;
29283 0 : if (jarg3) {
29284 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29285 0 : if (!arg3) return 0;
29286 : }
29287 0 : arg4 = 0;
29288 0 : if (jarg4) {
29289 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
29290 0 : if (!arg4) return 0;
29291 : }
29292 : {
29293 0 : if (!arg1) {
29294 : {
29295 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29296 : };
29297 : }
29298 : }
29299 : {
29300 0 : if (!arg2) {
29301 : {
29302 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29303 : };
29304 : }
29305 : }
29306 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3,(char const *)arg4);
29307 0 : jresult = (jint)result;
29308 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29309 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
29310 0 : return jresult;
29311 : }
29312 :
29313 :
29314 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_17(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) {
29315 0 : jint jresult = 0 ;
29316 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29317 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29318 0 : char *arg3 = (char *) 0 ;
29319 : CPLErr result;
29320 :
29321 : (void)jenv;
29322 : (void)jcls;
29323 : (void)jarg1_;
29324 : (void)jarg2_;
29325 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29326 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29327 0 : arg3 = 0;
29328 0 : if (jarg3) {
29329 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
29330 0 : if (!arg3) return 0;
29331 : }
29332 : {
29333 0 : if (!arg1) {
29334 : {
29335 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29336 : };
29337 : }
29338 : }
29339 : {
29340 0 : if (!arg2) {
29341 : {
29342 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29343 : };
29344 : }
29345 : }
29346 0 : result = (CPLErr)ReprojectImage(arg1,arg2,(char const *)arg3);
29347 0 : jresult = (jint)result;
29348 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
29349 0 : return jresult;
29350 : }
29351 :
29352 :
29353 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ReprojectImage_1_1SWIG_18(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
29354 0 : jint jresult = 0 ;
29355 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29356 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
29357 : CPLErr result;
29358 :
29359 : (void)jenv;
29360 : (void)jcls;
29361 : (void)jarg1_;
29362 : (void)jarg2_;
29363 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29364 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
29365 : {
29366 0 : if (!arg1) {
29367 : {
29368 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29369 : };
29370 : }
29371 : }
29372 : {
29373 0 : if (!arg2) {
29374 : {
29375 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29376 : };
29377 : }
29378 : }
29379 0 : result = (CPLErr)ReprojectImage(arg1,arg2);
29380 0 : jresult = (jint)result;
29381 0 : return jresult;
29382 : }
29383 :
29384 :
29385 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ComputeProximity_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) {
29386 0 : jint jresult = 0 ;
29387 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
29388 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
29389 0 : char **arg3 = (char **) 0 ;
29390 : GDALProgressFunc arg4 ;
29391 0 : void *arg5 = (void *) 0 ;
29392 : int result;
29393 :
29394 : (void)jenv;
29395 : (void)jcls;
29396 : JavaProgressData sProgressInfo;
29397 0 : sProgressInfo.jenv = jenv;
29398 0 : sProgressInfo.pJavaCallback = NULL;
29399 : (void)jarg1_;
29400 : (void)jarg2_;
29401 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
29402 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
29403 : {
29404 : /* %typemap(in) char **options */
29405 0 : arg3 = NULL;
29406 0 : if(jarg3 != 0) {
29407 0 : const jclass vector = jenv->FindClass("java/util/Vector");
29408 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
29409 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
29410 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
29411 : "()Ljava/util/Enumeration;");
29412 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
29413 : "hasMoreElements", "()Z");
29414 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
29415 : "nextElement", "()Ljava/lang/Object;");
29416 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
29417 0 : hasMoreElements == NULL || getNextElement == NULL) {
29418 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
29419 0 : return 0;
29420 : }
29421 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
29422 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
29423 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
29424 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
29425 : {
29426 0 : CSLDestroy(arg3);
29427 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
29428 0 : return 0;
29429 : }
29430 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
29431 0 : arg3 = CSLAddString(arg3, valptr);
29432 0 : jenv->ReleaseStringUTFChars(value, valptr);
29433 : }
29434 : }
29435 : }
29436 : {
29437 0 : if ( jarg4 != 0 ) {
29438 0 : sProgressInfo.pJavaCallback = jarg4;
29439 0 : arg4 = JavaProgressProxy;
29440 0 : arg5 = &sProgressInfo;
29441 : }
29442 : else
29443 : {
29444 0 : arg4 = NULL;
29445 0 : arg5 = NULL;
29446 : }
29447 : }
29448 : {
29449 0 : if (!arg1) {
29450 : {
29451 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29452 : };
29453 : }
29454 : }
29455 : {
29456 0 : if (!arg2) {
29457 : {
29458 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29459 : };
29460 : }
29461 : }
29462 0 : result = (int)ComputeProximity(arg1,arg2,arg3,arg4,arg5);
29463 0 : jresult = (jint)result;
29464 : {
29465 : /* %typemap(freearg) char **options */
29466 0 : CSLDestroy( arg3 );
29467 : }
29468 0 : return jresult;
29469 : }
29470 :
29471 :
29472 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ComputeProximity_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3) {
29473 0 : jint jresult = 0 ;
29474 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
29475 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
29476 0 : char **arg3 = (char **) 0 ;
29477 : int result;
29478 :
29479 : (void)jenv;
29480 : (void)jcls;
29481 : (void)jarg1_;
29482 : (void)jarg2_;
29483 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
29484 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
29485 : {
29486 : /* %typemap(in) char **options */
29487 0 : arg3 = NULL;
29488 0 : if(jarg3 != 0) {
29489 0 : const jclass vector = jenv->FindClass("java/util/Vector");
29490 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
29491 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
29492 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
29493 : "()Ljava/util/Enumeration;");
29494 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
29495 : "hasMoreElements", "()Z");
29496 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
29497 : "nextElement", "()Ljava/lang/Object;");
29498 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
29499 0 : hasMoreElements == NULL || getNextElement == NULL) {
29500 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
29501 0 : return 0;
29502 : }
29503 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
29504 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
29505 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
29506 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
29507 : {
29508 0 : CSLDestroy(arg3);
29509 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
29510 0 : return 0;
29511 : }
29512 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
29513 0 : arg3 = CSLAddString(arg3, valptr);
29514 0 : jenv->ReleaseStringUTFChars(value, valptr);
29515 : }
29516 : }
29517 : }
29518 : {
29519 0 : if (!arg1) {
29520 : {
29521 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29522 : };
29523 : }
29524 : }
29525 : {
29526 0 : if (!arg2) {
29527 : {
29528 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29529 : };
29530 : }
29531 : }
29532 0 : result = (int)ComputeProximity(arg1,arg2,arg3);
29533 0 : jresult = (jint)result;
29534 : {
29535 : /* %typemap(freearg) char **options */
29536 0 : CSLDestroy( arg3 );
29537 : }
29538 0 : return jresult;
29539 : }
29540 :
29541 :
29542 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ComputeProximity_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
29543 0 : jint jresult = 0 ;
29544 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
29545 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
29546 : int result;
29547 :
29548 : (void)jenv;
29549 : (void)jcls;
29550 : (void)jarg1_;
29551 : (void)jarg2_;
29552 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
29553 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
29554 : {
29555 0 : if (!arg1) {
29556 : {
29557 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29558 : };
29559 : }
29560 : }
29561 : {
29562 0 : if (!arg2) {
29563 : {
29564 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29565 : };
29566 : }
29567 : }
29568 0 : result = (int)ComputeProximity(arg1,arg2);
29569 0 : jresult = (jint)result;
29570 0 : return jresult;
29571 : }
29572 :
29573 :
29574 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterizeLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2, jlong jarg4, jobject jarg4_, jdoubleArray jarg5, jobject jarg7, jobject jarg8) {
29575 0 : jint jresult = 0 ;
29576 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29577 : int arg2 ;
29578 0 : int *arg3 = (int *) 0 ;
29579 0 : OGRLayerShadow *arg4 = (OGRLayerShadow *) 0 ;
29580 : int arg5 ;
29581 0 : double *arg6 = (double *) 0 ;
29582 0 : char **arg7 = (char **) 0 ;
29583 : GDALProgressFunc arg8 ;
29584 0 : void *arg9 = (void *) 0 ;
29585 : int result;
29586 :
29587 : (void)jenv;
29588 : (void)jcls;
29589 : JavaProgressData sProgressInfo;
29590 0 : sProgressInfo.jenv = jenv;
29591 0 : sProgressInfo.pJavaCallback = NULL;
29592 : (void)jarg1_;
29593 : (void)jarg4_;
29594 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29595 : {
29596 : /* %typemap(in) (int nList, int* pList) */
29597 : /* check if is List */
29598 0 : if (jarg2)
29599 : {
29600 0 : arg2 = jenv->GetArrayLength(jarg2);
29601 0 : if (arg2 == 0)
29602 0 : arg3 = NULL;
29603 : else
29604 0 : arg3 = (int *)jenv->GetIntArrayElements(jarg2, NULL);
29605 : }
29606 : else
29607 : {
29608 0 : arg2 = 0;
29609 0 : arg3 = NULL;
29610 : }
29611 : }
29612 0 : arg4 = *(OGRLayerShadow **)&jarg4;
29613 : {
29614 : /* %typemap(in) (int nList, double* pList) */
29615 : /* check if is List */
29616 0 : if (jarg5)
29617 : {
29618 0 : arg5 = jenv->GetArrayLength(jarg5);
29619 0 : if (arg5 == 0)
29620 0 : arg6 = NULL;
29621 : else
29622 0 : arg6 = (double *)jenv->GetDoubleArrayElements(jarg5, NULL);
29623 : }
29624 : else
29625 : {
29626 0 : arg5 = 0;
29627 0 : arg6 = NULL;
29628 : }
29629 : }
29630 : {
29631 : /* %typemap(in) char **options */
29632 0 : arg7 = NULL;
29633 0 : if(jarg7 != 0) {
29634 0 : const jclass vector = jenv->FindClass("java/util/Vector");
29635 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
29636 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
29637 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
29638 : "()Ljava/util/Enumeration;");
29639 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
29640 : "hasMoreElements", "()Z");
29641 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
29642 : "nextElement", "()Ljava/lang/Object;");
29643 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
29644 0 : hasMoreElements == NULL || getNextElement == NULL) {
29645 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
29646 0 : return 0;
29647 : }
29648 0 : for (jobject keys = jenv->CallObjectMethod(jarg7, elements);
29649 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
29650 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
29651 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
29652 : {
29653 0 : CSLDestroy(arg7);
29654 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
29655 0 : return 0;
29656 : }
29657 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
29658 0 : arg7 = CSLAddString(arg7, valptr);
29659 0 : jenv->ReleaseStringUTFChars(value, valptr);
29660 : }
29661 : }
29662 : }
29663 : {
29664 0 : if ( jarg8 != 0 ) {
29665 0 : sProgressInfo.pJavaCallback = jarg8;
29666 0 : arg8 = JavaProgressProxy;
29667 0 : arg9 = &sProgressInfo;
29668 : }
29669 : else
29670 : {
29671 0 : arg8 = NULL;
29672 0 : arg9 = NULL;
29673 : }
29674 : }
29675 : {
29676 0 : if (!arg1) {
29677 : {
29678 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29679 : };
29680 : }
29681 : }
29682 : {
29683 0 : if (!arg4) {
29684 : {
29685 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29686 : };
29687 : }
29688 : }
29689 0 : result = (int)RasterizeLayer(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
29690 0 : jresult = (jint)result;
29691 : {
29692 : /* %typemap(argout) (int nList, int* pList) */
29693 : }
29694 : {
29695 : /* %typemap(argout) (int nList, double* pList) */
29696 : }
29697 : {
29698 : /* %typemap(freearg) (int nList, int* pList) */
29699 0 : if (arg3) {
29700 0 : jenv->ReleaseIntArrayElements(jarg2, (jint*)arg3, JNI_ABORT);
29701 : }
29702 : }
29703 : {
29704 : /* %typemap(freearg) (int nList, double* pList) */
29705 0 : if (arg6) {
29706 0 : jenv->ReleaseDoubleArrayElements(jarg5, arg6, JNI_ABORT);
29707 : }
29708 : }
29709 : {
29710 : /* %typemap(freearg) char **options */
29711 0 : CSLDestroy( arg7 );
29712 : }
29713 0 : return jresult;
29714 : }
29715 :
29716 :
29717 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterizeLayer_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2, jlong jarg4, jobject jarg4_, jdoubleArray jarg5, jobject jarg7) {
29718 0 : jint jresult = 0 ;
29719 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29720 : int arg2 ;
29721 0 : int *arg3 = (int *) 0 ;
29722 0 : OGRLayerShadow *arg4 = (OGRLayerShadow *) 0 ;
29723 : int arg5 ;
29724 0 : double *arg6 = (double *) 0 ;
29725 0 : char **arg7 = (char **) 0 ;
29726 : int result;
29727 :
29728 : (void)jenv;
29729 : (void)jcls;
29730 : (void)jarg1_;
29731 : (void)jarg4_;
29732 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29733 : {
29734 : /* %typemap(in) (int nList, int* pList) */
29735 : /* check if is List */
29736 0 : if (jarg2)
29737 : {
29738 0 : arg2 = jenv->GetArrayLength(jarg2);
29739 0 : if (arg2 == 0)
29740 0 : arg3 = NULL;
29741 : else
29742 0 : arg3 = (int *)jenv->GetIntArrayElements(jarg2, NULL);
29743 : }
29744 : else
29745 : {
29746 0 : arg2 = 0;
29747 0 : arg3 = NULL;
29748 : }
29749 : }
29750 0 : arg4 = *(OGRLayerShadow **)&jarg4;
29751 : {
29752 : /* %typemap(in) (int nList, double* pList) */
29753 : /* check if is List */
29754 0 : if (jarg5)
29755 : {
29756 0 : arg5 = jenv->GetArrayLength(jarg5);
29757 0 : if (arg5 == 0)
29758 0 : arg6 = NULL;
29759 : else
29760 0 : arg6 = (double *)jenv->GetDoubleArrayElements(jarg5, NULL);
29761 : }
29762 : else
29763 : {
29764 0 : arg5 = 0;
29765 0 : arg6 = NULL;
29766 : }
29767 : }
29768 : {
29769 : /* %typemap(in) char **options */
29770 0 : arg7 = NULL;
29771 0 : if(jarg7 != 0) {
29772 0 : const jclass vector = jenv->FindClass("java/util/Vector");
29773 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
29774 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
29775 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
29776 : "()Ljava/util/Enumeration;");
29777 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
29778 : "hasMoreElements", "()Z");
29779 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
29780 : "nextElement", "()Ljava/lang/Object;");
29781 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
29782 0 : hasMoreElements == NULL || getNextElement == NULL) {
29783 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
29784 0 : return 0;
29785 : }
29786 0 : for (jobject keys = jenv->CallObjectMethod(jarg7, elements);
29787 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
29788 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
29789 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
29790 : {
29791 0 : CSLDestroy(arg7);
29792 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
29793 0 : return 0;
29794 : }
29795 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
29796 0 : arg7 = CSLAddString(arg7, valptr);
29797 0 : jenv->ReleaseStringUTFChars(value, valptr);
29798 : }
29799 : }
29800 : }
29801 : {
29802 0 : if (!arg1) {
29803 : {
29804 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29805 : };
29806 : }
29807 : }
29808 : {
29809 0 : if (!arg4) {
29810 : {
29811 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29812 : };
29813 : }
29814 : }
29815 0 : result = (int)RasterizeLayer(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
29816 0 : jresult = (jint)result;
29817 : {
29818 : /* %typemap(argout) (int nList, int* pList) */
29819 : }
29820 : {
29821 : /* %typemap(argout) (int nList, double* pList) */
29822 : }
29823 : {
29824 : /* %typemap(freearg) (int nList, int* pList) */
29825 0 : if (arg3) {
29826 0 : jenv->ReleaseIntArrayElements(jarg2, (jint*)arg3, JNI_ABORT);
29827 : }
29828 : }
29829 : {
29830 : /* %typemap(freearg) (int nList, double* pList) */
29831 0 : if (arg6) {
29832 0 : jenv->ReleaseDoubleArrayElements(jarg5, arg6, JNI_ABORT);
29833 : }
29834 : }
29835 : {
29836 : /* %typemap(freearg) char **options */
29837 0 : CSLDestroy( arg7 );
29838 : }
29839 0 : return jresult;
29840 : }
29841 :
29842 :
29843 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterizeLayer_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2, jlong jarg4, jobject jarg4_, jdoubleArray jarg5) {
29844 0 : jint jresult = 0 ;
29845 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29846 : int arg2 ;
29847 0 : int *arg3 = (int *) 0 ;
29848 0 : OGRLayerShadow *arg4 = (OGRLayerShadow *) 0 ;
29849 : int arg5 ;
29850 0 : double *arg6 = (double *) 0 ;
29851 : int result;
29852 :
29853 : (void)jenv;
29854 : (void)jcls;
29855 : (void)jarg1_;
29856 : (void)jarg4_;
29857 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29858 : {
29859 : /* %typemap(in) (int nList, int* pList) */
29860 : /* check if is List */
29861 0 : if (jarg2)
29862 : {
29863 0 : arg2 = jenv->GetArrayLength(jarg2);
29864 0 : if (arg2 == 0)
29865 0 : arg3 = NULL;
29866 : else
29867 0 : arg3 = (int *)jenv->GetIntArrayElements(jarg2, NULL);
29868 : }
29869 : else
29870 : {
29871 0 : arg2 = 0;
29872 0 : arg3 = NULL;
29873 : }
29874 : }
29875 0 : arg4 = *(OGRLayerShadow **)&jarg4;
29876 : {
29877 : /* %typemap(in) (int nList, double* pList) */
29878 : /* check if is List */
29879 0 : if (jarg5)
29880 : {
29881 0 : arg5 = jenv->GetArrayLength(jarg5);
29882 0 : if (arg5 == 0)
29883 0 : arg6 = NULL;
29884 : else
29885 0 : arg6 = (double *)jenv->GetDoubleArrayElements(jarg5, NULL);
29886 : }
29887 : else
29888 : {
29889 0 : arg5 = 0;
29890 0 : arg6 = NULL;
29891 : }
29892 : }
29893 : {
29894 0 : if (!arg1) {
29895 : {
29896 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29897 : };
29898 : }
29899 : }
29900 : {
29901 0 : if (!arg4) {
29902 : {
29903 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29904 : };
29905 : }
29906 : }
29907 0 : result = (int)RasterizeLayer(arg1,arg2,arg3,arg4,arg5,arg6);
29908 0 : jresult = (jint)result;
29909 : {
29910 : /* %typemap(argout) (int nList, int* pList) */
29911 : }
29912 : {
29913 : /* %typemap(argout) (int nList, double* pList) */
29914 : }
29915 : {
29916 : /* %typemap(freearg) (int nList, int* pList) */
29917 0 : if (arg3) {
29918 0 : jenv->ReleaseIntArrayElements(jarg2, (jint*)arg3, JNI_ABORT);
29919 : }
29920 : }
29921 : {
29922 : /* %typemap(freearg) (int nList, double* pList) */
29923 0 : if (arg6) {
29924 0 : jenv->ReleaseDoubleArrayElements(jarg5, arg6, JNI_ABORT);
29925 : }
29926 : }
29927 0 : return jresult;
29928 : }
29929 :
29930 :
29931 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RasterizeLayer_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jintArray jarg2, jlong jarg4, jobject jarg4_) {
29932 0 : jint jresult = 0 ;
29933 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
29934 : int arg2 ;
29935 0 : int *arg3 = (int *) 0 ;
29936 0 : OGRLayerShadow *arg4 = (OGRLayerShadow *) 0 ;
29937 : int result;
29938 :
29939 : (void)jenv;
29940 : (void)jcls;
29941 : (void)jarg1_;
29942 : (void)jarg4_;
29943 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
29944 : {
29945 : /* %typemap(in) (int nList, int* pList) */
29946 : /* check if is List */
29947 0 : if (jarg2)
29948 : {
29949 0 : arg2 = jenv->GetArrayLength(jarg2);
29950 0 : if (arg2 == 0)
29951 0 : arg3 = NULL;
29952 : else
29953 0 : arg3 = (int *)jenv->GetIntArrayElements(jarg2, NULL);
29954 : }
29955 : else
29956 : {
29957 0 : arg2 = 0;
29958 0 : arg3 = NULL;
29959 : }
29960 : }
29961 0 : arg4 = *(OGRLayerShadow **)&jarg4;
29962 : {
29963 0 : if (!arg1) {
29964 : {
29965 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29966 : };
29967 : }
29968 : }
29969 : {
29970 0 : if (!arg4) {
29971 : {
29972 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
29973 : };
29974 : }
29975 : }
29976 0 : result = (int)RasterizeLayer(arg1,arg2,arg3,arg4);
29977 0 : jresult = (jint)result;
29978 : {
29979 : /* %typemap(argout) (int nList, int* pList) */
29980 : }
29981 : {
29982 : /* %typemap(freearg) (int nList, int* pList) */
29983 0 : if (arg3) {
29984 0 : jenv->ReleaseIntArrayElements(jarg2, (jint*)arg3, JNI_ABORT);
29985 : }
29986 : }
29987 0 : return jresult;
29988 : }
29989 :
29990 :
29991 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Polygonize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5, jobject jarg6) {
29992 0 : jint jresult = 0 ;
29993 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
29994 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
29995 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
29996 : int arg4 ;
29997 0 : char **arg5 = (char **) 0 ;
29998 : GDALProgressFunc arg6 ;
29999 0 : void *arg7 = (void *) 0 ;
30000 : int result;
30001 :
30002 : (void)jenv;
30003 : (void)jcls;
30004 : JavaProgressData sProgressInfo;
30005 0 : sProgressInfo.jenv = jenv;
30006 0 : sProgressInfo.pJavaCallback = NULL;
30007 : (void)jarg1_;
30008 : (void)jarg2_;
30009 : (void)jarg3_;
30010 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30011 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30012 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30013 0 : arg4 = (int)jarg4;
30014 : {
30015 : /* %typemap(in) char **options */
30016 0 : arg5 = NULL;
30017 0 : if(jarg5 != 0) {
30018 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30019 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30020 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30021 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30022 : "()Ljava/util/Enumeration;");
30023 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30024 : "hasMoreElements", "()Z");
30025 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30026 : "nextElement", "()Ljava/lang/Object;");
30027 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30028 0 : hasMoreElements == NULL || getNextElement == NULL) {
30029 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30030 0 : return 0;
30031 : }
30032 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30033 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30034 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30035 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30036 : {
30037 0 : CSLDestroy(arg5);
30038 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30039 0 : return 0;
30040 : }
30041 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30042 0 : arg5 = CSLAddString(arg5, valptr);
30043 0 : jenv->ReleaseStringUTFChars(value, valptr);
30044 : }
30045 : }
30046 : }
30047 : {
30048 0 : if ( jarg6 != 0 ) {
30049 0 : sProgressInfo.pJavaCallback = jarg6;
30050 0 : arg6 = JavaProgressProxy;
30051 0 : arg7 = &sProgressInfo;
30052 : }
30053 : else
30054 : {
30055 0 : arg6 = NULL;
30056 0 : arg7 = NULL;
30057 : }
30058 : }
30059 : {
30060 0 : if (!arg1) {
30061 : {
30062 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30063 : };
30064 : }
30065 : }
30066 : {
30067 0 : if (!arg3) {
30068 : {
30069 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30070 : };
30071 : }
30072 : }
30073 0 : result = (int)Polygonize(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
30074 0 : jresult = (jint)result;
30075 : {
30076 : /* %typemap(freearg) char **options */
30077 0 : CSLDestroy( arg5 );
30078 : }
30079 0 : return jresult;
30080 : }
30081 :
30082 :
30083 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Polygonize_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5) {
30084 0 : jint jresult = 0 ;
30085 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30086 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30087 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
30088 : int arg4 ;
30089 0 : char **arg5 = (char **) 0 ;
30090 : int result;
30091 :
30092 : (void)jenv;
30093 : (void)jcls;
30094 : (void)jarg1_;
30095 : (void)jarg2_;
30096 : (void)jarg3_;
30097 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30098 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30099 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30100 0 : arg4 = (int)jarg4;
30101 : {
30102 : /* %typemap(in) char **options */
30103 0 : arg5 = NULL;
30104 0 : if(jarg5 != 0) {
30105 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30106 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30107 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30108 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30109 : "()Ljava/util/Enumeration;");
30110 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30111 : "hasMoreElements", "()Z");
30112 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30113 : "nextElement", "()Ljava/lang/Object;");
30114 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30115 0 : hasMoreElements == NULL || getNextElement == NULL) {
30116 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30117 0 : return 0;
30118 : }
30119 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30120 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30121 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30122 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30123 : {
30124 0 : CSLDestroy(arg5);
30125 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30126 0 : return 0;
30127 : }
30128 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30129 0 : arg5 = CSLAddString(arg5, valptr);
30130 0 : jenv->ReleaseStringUTFChars(value, valptr);
30131 : }
30132 : }
30133 : }
30134 : {
30135 0 : if (!arg1) {
30136 : {
30137 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30138 : };
30139 : }
30140 : }
30141 : {
30142 0 : if (!arg3) {
30143 : {
30144 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30145 : };
30146 : }
30147 : }
30148 0 : result = (int)Polygonize(arg1,arg2,arg3,arg4,arg5);
30149 0 : jresult = (jint)result;
30150 : {
30151 : /* %typemap(freearg) char **options */
30152 0 : CSLDestroy( arg5 );
30153 : }
30154 0 : return jresult;
30155 : }
30156 :
30157 :
30158 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Polygonize_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4) {
30159 0 : jint jresult = 0 ;
30160 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30161 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30162 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
30163 : int arg4 ;
30164 : int result;
30165 :
30166 : (void)jenv;
30167 : (void)jcls;
30168 : (void)jarg1_;
30169 : (void)jarg2_;
30170 : (void)jarg3_;
30171 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30172 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30173 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30174 0 : arg4 = (int)jarg4;
30175 : {
30176 0 : if (!arg1) {
30177 : {
30178 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30179 : };
30180 : }
30181 : }
30182 : {
30183 0 : if (!arg3) {
30184 : {
30185 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30186 : };
30187 : }
30188 : }
30189 0 : result = (int)Polygonize(arg1,arg2,arg3,arg4);
30190 0 : jresult = (jint)result;
30191 0 : return jresult;
30192 : }
30193 :
30194 :
30195 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FPolygonize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5, jobject jarg6) {
30196 0 : jint jresult = 0 ;
30197 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30198 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30199 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
30200 : int arg4 ;
30201 0 : char **arg5 = (char **) 0 ;
30202 : GDALProgressFunc arg6 ;
30203 0 : void *arg7 = (void *) 0 ;
30204 : int result;
30205 :
30206 : (void)jenv;
30207 : (void)jcls;
30208 : JavaProgressData sProgressInfo;
30209 0 : sProgressInfo.jenv = jenv;
30210 0 : sProgressInfo.pJavaCallback = NULL;
30211 : (void)jarg1_;
30212 : (void)jarg2_;
30213 : (void)jarg3_;
30214 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30215 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30216 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30217 0 : arg4 = (int)jarg4;
30218 : {
30219 : /* %typemap(in) char **options */
30220 0 : arg5 = NULL;
30221 0 : if(jarg5 != 0) {
30222 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30223 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30224 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30225 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30226 : "()Ljava/util/Enumeration;");
30227 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30228 : "hasMoreElements", "()Z");
30229 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30230 : "nextElement", "()Ljava/lang/Object;");
30231 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30232 0 : hasMoreElements == NULL || getNextElement == NULL) {
30233 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30234 0 : return 0;
30235 : }
30236 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30237 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30238 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30239 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30240 : {
30241 0 : CSLDestroy(arg5);
30242 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30243 0 : return 0;
30244 : }
30245 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30246 0 : arg5 = CSLAddString(arg5, valptr);
30247 0 : jenv->ReleaseStringUTFChars(value, valptr);
30248 : }
30249 : }
30250 : }
30251 : {
30252 0 : if ( jarg6 != 0 ) {
30253 0 : sProgressInfo.pJavaCallback = jarg6;
30254 0 : arg6 = JavaProgressProxy;
30255 0 : arg7 = &sProgressInfo;
30256 : }
30257 : else
30258 : {
30259 0 : arg6 = NULL;
30260 0 : arg7 = NULL;
30261 : }
30262 : }
30263 : {
30264 0 : if (!arg1) {
30265 : {
30266 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30267 : };
30268 : }
30269 : }
30270 : {
30271 0 : if (!arg3) {
30272 : {
30273 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30274 : };
30275 : }
30276 : }
30277 0 : result = (int)FPolygonize(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
30278 0 : jresult = (jint)result;
30279 : {
30280 : /* %typemap(freearg) char **options */
30281 0 : CSLDestroy( arg5 );
30282 : }
30283 0 : return jresult;
30284 : }
30285 :
30286 :
30287 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FPolygonize_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5) {
30288 0 : jint jresult = 0 ;
30289 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30290 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30291 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
30292 : int arg4 ;
30293 0 : char **arg5 = (char **) 0 ;
30294 : int result;
30295 :
30296 : (void)jenv;
30297 : (void)jcls;
30298 : (void)jarg1_;
30299 : (void)jarg2_;
30300 : (void)jarg3_;
30301 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30302 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30303 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30304 0 : arg4 = (int)jarg4;
30305 : {
30306 : /* %typemap(in) char **options */
30307 0 : arg5 = NULL;
30308 0 : if(jarg5 != 0) {
30309 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30310 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30311 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30312 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30313 : "()Ljava/util/Enumeration;");
30314 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30315 : "hasMoreElements", "()Z");
30316 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30317 : "nextElement", "()Ljava/lang/Object;");
30318 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30319 0 : hasMoreElements == NULL || getNextElement == NULL) {
30320 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30321 0 : return 0;
30322 : }
30323 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30324 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30325 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30326 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30327 : {
30328 0 : CSLDestroy(arg5);
30329 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30330 0 : return 0;
30331 : }
30332 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30333 0 : arg5 = CSLAddString(arg5, valptr);
30334 0 : jenv->ReleaseStringUTFChars(value, valptr);
30335 : }
30336 : }
30337 : }
30338 : {
30339 0 : if (!arg1) {
30340 : {
30341 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30342 : };
30343 : }
30344 : }
30345 : {
30346 0 : if (!arg3) {
30347 : {
30348 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30349 : };
30350 : }
30351 : }
30352 0 : result = (int)FPolygonize(arg1,arg2,arg3,arg4,arg5);
30353 0 : jresult = (jint)result;
30354 : {
30355 : /* %typemap(freearg) char **options */
30356 0 : CSLDestroy( arg5 );
30357 : }
30358 0 : return jresult;
30359 : }
30360 :
30361 :
30362 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FPolygonize_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4) {
30363 0 : jint jresult = 0 ;
30364 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30365 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30366 0 : OGRLayerShadow *arg3 = (OGRLayerShadow *) 0 ;
30367 : int arg4 ;
30368 : int result;
30369 :
30370 : (void)jenv;
30371 : (void)jcls;
30372 : (void)jarg1_;
30373 : (void)jarg2_;
30374 : (void)jarg3_;
30375 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30376 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30377 0 : arg3 = *(OGRLayerShadow **)&jarg3;
30378 0 : arg4 = (int)jarg4;
30379 : {
30380 0 : if (!arg1) {
30381 : {
30382 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30383 : };
30384 : }
30385 : }
30386 : {
30387 0 : if (!arg3) {
30388 : {
30389 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30390 : };
30391 : }
30392 : }
30393 0 : result = (int)FPolygonize(arg1,arg2,arg3,arg4);
30394 0 : jresult = (jint)result;
30395 0 : return jresult;
30396 : }
30397 :
30398 :
30399 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FillNodata_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jdouble jarg3, jint jarg4, jobject jarg5, jobject jarg6) {
30400 0 : jint jresult = 0 ;
30401 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30402 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30403 : double arg3 ;
30404 : int arg4 ;
30405 0 : char **arg5 = (char **) 0 ;
30406 : GDALProgressFunc arg6 ;
30407 0 : void *arg7 = (void *) 0 ;
30408 : int result;
30409 :
30410 : (void)jenv;
30411 : (void)jcls;
30412 : JavaProgressData sProgressInfo;
30413 0 : sProgressInfo.jenv = jenv;
30414 0 : sProgressInfo.pJavaCallback = NULL;
30415 : (void)jarg1_;
30416 : (void)jarg2_;
30417 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30418 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30419 0 : arg3 = (double)jarg3;
30420 0 : arg4 = (int)jarg4;
30421 : {
30422 : /* %typemap(in) char **options */
30423 0 : arg5 = NULL;
30424 0 : if(jarg5 != 0) {
30425 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30426 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30427 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30428 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30429 : "()Ljava/util/Enumeration;");
30430 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30431 : "hasMoreElements", "()Z");
30432 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30433 : "nextElement", "()Ljava/lang/Object;");
30434 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30435 0 : hasMoreElements == NULL || getNextElement == NULL) {
30436 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30437 0 : return 0;
30438 : }
30439 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30440 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30441 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30442 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30443 : {
30444 0 : CSLDestroy(arg5);
30445 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30446 0 : return 0;
30447 : }
30448 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30449 0 : arg5 = CSLAddString(arg5, valptr);
30450 0 : jenv->ReleaseStringUTFChars(value, valptr);
30451 : }
30452 : }
30453 : }
30454 : {
30455 0 : if ( jarg6 != 0 ) {
30456 0 : sProgressInfo.pJavaCallback = jarg6;
30457 0 : arg6 = JavaProgressProxy;
30458 0 : arg7 = &sProgressInfo;
30459 : }
30460 : else
30461 : {
30462 0 : arg6 = NULL;
30463 0 : arg7 = NULL;
30464 : }
30465 : }
30466 : {
30467 0 : if (!arg1) {
30468 : {
30469 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30470 : };
30471 : }
30472 : }
30473 0 : result = (int)FillNodata(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
30474 0 : jresult = (jint)result;
30475 : {
30476 : /* %typemap(freearg) char **options */
30477 0 : CSLDestroy( arg5 );
30478 : }
30479 0 : return jresult;
30480 : }
30481 :
30482 :
30483 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FillNodata_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jdouble jarg3, jint jarg4, jobject jarg5) {
30484 0 : jint jresult = 0 ;
30485 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30486 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30487 : double arg3 ;
30488 : int arg4 ;
30489 0 : char **arg5 = (char **) 0 ;
30490 : int result;
30491 :
30492 : (void)jenv;
30493 : (void)jcls;
30494 : (void)jarg1_;
30495 : (void)jarg2_;
30496 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30497 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30498 0 : arg3 = (double)jarg3;
30499 0 : arg4 = (int)jarg4;
30500 : {
30501 : /* %typemap(in) char **options */
30502 0 : arg5 = NULL;
30503 0 : if(jarg5 != 0) {
30504 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30505 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30506 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30507 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30508 : "()Ljava/util/Enumeration;");
30509 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30510 : "hasMoreElements", "()Z");
30511 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30512 : "nextElement", "()Ljava/lang/Object;");
30513 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30514 0 : hasMoreElements == NULL || getNextElement == NULL) {
30515 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30516 0 : return 0;
30517 : }
30518 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
30519 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30520 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30521 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30522 : {
30523 0 : CSLDestroy(arg5);
30524 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30525 0 : return 0;
30526 : }
30527 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30528 0 : arg5 = CSLAddString(arg5, valptr);
30529 0 : jenv->ReleaseStringUTFChars(value, valptr);
30530 : }
30531 : }
30532 : }
30533 : {
30534 0 : if (!arg1) {
30535 : {
30536 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30537 : };
30538 : }
30539 : }
30540 0 : result = (int)FillNodata(arg1,arg2,arg3,arg4,arg5);
30541 0 : jresult = (jint)result;
30542 : {
30543 : /* %typemap(freearg) char **options */
30544 0 : CSLDestroy( arg5 );
30545 : }
30546 0 : return jresult;
30547 : }
30548 :
30549 :
30550 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_FillNodata_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jdouble jarg3, jint jarg4) {
30551 0 : jint jresult = 0 ;
30552 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30553 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30554 : double arg3 ;
30555 : int arg4 ;
30556 : int result;
30557 :
30558 : (void)jenv;
30559 : (void)jcls;
30560 : (void)jarg1_;
30561 : (void)jarg2_;
30562 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30563 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30564 0 : arg3 = (double)jarg3;
30565 0 : arg4 = (int)jarg4;
30566 : {
30567 0 : if (!arg1) {
30568 : {
30569 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30570 : };
30571 : }
30572 : }
30573 0 : result = (int)FillNodata(arg1,arg2,arg3,arg4);
30574 0 : jresult = (jint)result;
30575 0 : return jresult;
30576 : }
30577 :
30578 :
30579 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SieveFilter_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5, jobject jarg6, jobject jarg7) {
30580 0 : jint jresult = 0 ;
30581 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30582 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30583 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
30584 : int arg4 ;
30585 : int arg5 ;
30586 0 : char **arg6 = (char **) 0 ;
30587 : GDALProgressFunc arg7 ;
30588 0 : void *arg8 = (void *) 0 ;
30589 : int result;
30590 :
30591 : (void)jenv;
30592 : (void)jcls;
30593 : JavaProgressData sProgressInfo;
30594 0 : sProgressInfo.jenv = jenv;
30595 0 : sProgressInfo.pJavaCallback = NULL;
30596 : (void)jarg1_;
30597 : (void)jarg2_;
30598 : (void)jarg3_;
30599 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30600 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30601 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
30602 0 : arg4 = (int)jarg4;
30603 0 : arg5 = (int)jarg5;
30604 : {
30605 : /* %typemap(in) char **options */
30606 0 : arg6 = NULL;
30607 0 : if(jarg6 != 0) {
30608 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30609 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30610 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30611 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30612 : "()Ljava/util/Enumeration;");
30613 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30614 : "hasMoreElements", "()Z");
30615 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30616 : "nextElement", "()Ljava/lang/Object;");
30617 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30618 0 : hasMoreElements == NULL || getNextElement == NULL) {
30619 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30620 0 : return 0;
30621 : }
30622 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
30623 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30624 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30625 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30626 : {
30627 0 : CSLDestroy(arg6);
30628 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30629 0 : return 0;
30630 : }
30631 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30632 0 : arg6 = CSLAddString(arg6, valptr);
30633 0 : jenv->ReleaseStringUTFChars(value, valptr);
30634 : }
30635 : }
30636 : }
30637 : {
30638 0 : if ( jarg7 != 0 ) {
30639 0 : sProgressInfo.pJavaCallback = jarg7;
30640 0 : arg7 = JavaProgressProxy;
30641 0 : arg8 = &sProgressInfo;
30642 : }
30643 : else
30644 : {
30645 0 : arg7 = NULL;
30646 0 : arg8 = NULL;
30647 : }
30648 : }
30649 : {
30650 0 : if (!arg1) {
30651 : {
30652 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30653 : };
30654 : }
30655 : }
30656 : {
30657 0 : if (!arg3) {
30658 : {
30659 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30660 : };
30661 : }
30662 : }
30663 0 : result = (int)SieveFilter(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
30664 0 : jresult = (jint)result;
30665 : {
30666 : /* %typemap(freearg) char **options */
30667 0 : CSLDestroy( arg6 );
30668 : }
30669 0 : return jresult;
30670 : }
30671 :
30672 :
30673 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SieveFilter_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5, jobject jarg6) {
30674 0 : jint jresult = 0 ;
30675 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30676 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30677 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
30678 : int arg4 ;
30679 : int arg5 ;
30680 0 : char **arg6 = (char **) 0 ;
30681 : int result;
30682 :
30683 : (void)jenv;
30684 : (void)jcls;
30685 : (void)jarg1_;
30686 : (void)jarg2_;
30687 : (void)jarg3_;
30688 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30689 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30690 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
30691 0 : arg4 = (int)jarg4;
30692 0 : arg5 = (int)jarg5;
30693 : {
30694 : /* %typemap(in) char **options */
30695 0 : arg6 = NULL;
30696 0 : if(jarg6 != 0) {
30697 0 : const jclass vector = jenv->FindClass("java/util/Vector");
30698 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
30699 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
30700 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
30701 : "()Ljava/util/Enumeration;");
30702 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
30703 : "hasMoreElements", "()Z");
30704 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
30705 : "nextElement", "()Ljava/lang/Object;");
30706 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
30707 0 : hasMoreElements == NULL || getNextElement == NULL) {
30708 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
30709 0 : return 0;
30710 : }
30711 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
30712 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
30713 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
30714 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
30715 : {
30716 0 : CSLDestroy(arg6);
30717 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
30718 0 : return 0;
30719 : }
30720 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
30721 0 : arg6 = CSLAddString(arg6, valptr);
30722 0 : jenv->ReleaseStringUTFChars(value, valptr);
30723 : }
30724 : }
30725 : }
30726 : {
30727 0 : if (!arg1) {
30728 : {
30729 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30730 : };
30731 : }
30732 : }
30733 : {
30734 0 : if (!arg3) {
30735 : {
30736 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30737 : };
30738 : }
30739 : }
30740 0 : result = (int)SieveFilter(arg1,arg2,arg3,arg4,arg5,arg6);
30741 0 : jresult = (jint)result;
30742 : {
30743 : /* %typemap(freearg) char **options */
30744 0 : CSLDestroy( arg6 );
30745 : }
30746 0 : return jresult;
30747 : }
30748 :
30749 :
30750 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SieveFilter_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4, jint jarg5) {
30751 0 : jint jresult = 0 ;
30752 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30753 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30754 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
30755 : int arg4 ;
30756 : int arg5 ;
30757 : int result;
30758 :
30759 : (void)jenv;
30760 : (void)jcls;
30761 : (void)jarg1_;
30762 : (void)jarg2_;
30763 : (void)jarg3_;
30764 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30765 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30766 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
30767 0 : arg4 = (int)jarg4;
30768 0 : arg5 = (int)jarg5;
30769 : {
30770 0 : if (!arg1) {
30771 : {
30772 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30773 : };
30774 : }
30775 : }
30776 : {
30777 0 : if (!arg3) {
30778 : {
30779 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30780 : };
30781 : }
30782 : }
30783 0 : result = (int)SieveFilter(arg1,arg2,arg3,arg4,arg5);
30784 0 : jresult = (jint)result;
30785 0 : return jresult;
30786 : }
30787 :
30788 :
30789 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SieveFilter_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jint jarg4) {
30790 0 : jint jresult = 0 ;
30791 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30792 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
30793 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
30794 : int arg4 ;
30795 : int result;
30796 :
30797 : (void)jenv;
30798 : (void)jcls;
30799 : (void)jarg1_;
30800 : (void)jarg2_;
30801 : (void)jarg3_;
30802 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30803 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
30804 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
30805 0 : arg4 = (int)jarg4;
30806 : {
30807 0 : if (!arg1) {
30808 : {
30809 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30810 : };
30811 : }
30812 : }
30813 : {
30814 0 : if (!arg3) {
30815 : {
30816 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30817 : };
30818 : }
30819 : }
30820 0 : result = (int)SieveFilter(arg1,arg2,arg3,arg4);
30821 0 : jresult = (jint)result;
30822 0 : return jresult;
30823 : }
30824 :
30825 :
30826 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverviews_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jstring jarg4, jobject jarg5) {
30827 0 : jint jresult = 0 ;
30828 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30829 : int arg2 ;
30830 0 : GDALRasterBandShadow **arg3 = (GDALRasterBandShadow **) 0 ;
30831 0 : char *arg4 = (char *) 0 ;
30832 : GDALProgressFunc arg5 ;
30833 0 : void *arg6 = (void *) 0 ;
30834 : int result;
30835 :
30836 : (void)jenv;
30837 : (void)jcls;
30838 : JavaProgressData sProgressInfo;
30839 0 : sProgressInfo.jenv = jenv;
30840 0 : sProgressInfo.pJavaCallback = NULL;
30841 : (void)jarg1_;
30842 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30843 : {
30844 : /* %typemap(in) (int object_list_count, GDALRasterBandShadow **poObjects) */
30845 : /* check if is List */
30846 0 : if (jarg2)
30847 : {
30848 0 : arg2 = jenv->GetArrayLength(jarg2);
30849 0 : if (arg2 == 0)
30850 0 : arg3 = NULL;
30851 : else
30852 : {
30853 0 : arg3 = (GDALRasterBandShadow**) malloc(sizeof(GDALRasterBandShadow*) * arg2);
30854 : int i;
30855 0 : for (i=0; i<arg2; i++) {
30856 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
30857 0 : if (obj == NULL)
30858 : {
30859 0 : free (arg3 );
30860 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
30861 0 : return 0;
30862 : }
30863 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Band");
30864 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Band;)J");
30865 0 : arg3[i] = (GDALRasterBandShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
30866 : }
30867 : }
30868 : }
30869 : else
30870 : {
30871 0 : arg2 = 0;
30872 0 : arg3 = NULL;
30873 : }
30874 : }
30875 : {
30876 : /* %typemap(in) (const char* stringWithDefaultValue) */
30877 0 : if (jarg4)
30878 : {
30879 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
30880 : }
30881 : }
30882 : {
30883 0 : if ( jarg5 != 0 ) {
30884 0 : sProgressInfo.pJavaCallback = jarg5;
30885 0 : arg5 = JavaProgressProxy;
30886 0 : arg6 = &sProgressInfo;
30887 : }
30888 : else
30889 : {
30890 0 : arg5 = NULL;
30891 0 : arg6 = NULL;
30892 : }
30893 : }
30894 : {
30895 0 : if (!arg1) {
30896 : {
30897 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30898 : };
30899 : }
30900 : }
30901 0 : result = (int)RegenerateOverviews(arg1,arg2,arg3,(char const *)arg4,arg5,arg6);
30902 0 : jresult = (jint)result;
30903 : {
30904 : /* %typemap(argout) (int object_list_count, GDALRasterBandShadow **poObjects) */
30905 : }
30906 : {
30907 : /* %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects) */
30908 0 : if (arg3) {
30909 0 : free((void*) arg3);
30910 : }
30911 : }
30912 : {
30913 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
30914 0 : if (jarg4)
30915 : {
30916 0 : jenv->ReleaseStringUTFChars(jarg4, (char*)arg4);
30917 : }
30918 : }
30919 0 : return jresult;
30920 : }
30921 :
30922 :
30923 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverviews_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jstring jarg4) {
30924 0 : jint jresult = 0 ;
30925 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
30926 : int arg2 ;
30927 0 : GDALRasterBandShadow **arg3 = (GDALRasterBandShadow **) 0 ;
30928 0 : char *arg4 = (char *) 0 ;
30929 : int result;
30930 :
30931 : (void)jenv;
30932 : (void)jcls;
30933 : (void)jarg1_;
30934 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
30935 : {
30936 : /* %typemap(in) (int object_list_count, GDALRasterBandShadow **poObjects) */
30937 : /* check if is List */
30938 0 : if (jarg2)
30939 : {
30940 0 : arg2 = jenv->GetArrayLength(jarg2);
30941 0 : if (arg2 == 0)
30942 0 : arg3 = NULL;
30943 : else
30944 : {
30945 0 : arg3 = (GDALRasterBandShadow**) malloc(sizeof(GDALRasterBandShadow*) * arg2);
30946 : int i;
30947 0 : for (i=0; i<arg2; i++) {
30948 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
30949 0 : if (obj == NULL)
30950 : {
30951 0 : free (arg3 );
30952 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
30953 0 : return 0;
30954 : }
30955 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Band");
30956 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Band;)J");
30957 0 : arg3[i] = (GDALRasterBandShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
30958 : }
30959 : }
30960 : }
30961 : else
30962 : {
30963 0 : arg2 = 0;
30964 0 : arg3 = NULL;
30965 : }
30966 : }
30967 : {
30968 : /* %typemap(in) (const char* stringWithDefaultValue) */
30969 0 : if (jarg4)
30970 : {
30971 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
30972 : }
30973 : }
30974 : {
30975 0 : if (!arg1) {
30976 : {
30977 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
30978 : };
30979 : }
30980 : }
30981 0 : result = (int)RegenerateOverviews(arg1,arg2,arg3,(char const *)arg4);
30982 0 : jresult = (jint)result;
30983 : {
30984 : /* %typemap(argout) (int object_list_count, GDALRasterBandShadow **poObjects) */
30985 : }
30986 : {
30987 : /* %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects) */
30988 0 : if (arg3) {
30989 0 : free((void*) arg3);
30990 : }
30991 : }
30992 : {
30993 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
30994 0 : if (jarg4)
30995 : {
30996 0 : jenv->ReleaseStringUTFChars(jarg4, (char*)arg4);
30997 : }
30998 : }
30999 0 : return jresult;
31000 : }
31001 :
31002 :
31003 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverviews_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2) {
31004 0 : jint jresult = 0 ;
31005 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31006 : int arg2 ;
31007 0 : GDALRasterBandShadow **arg3 = (GDALRasterBandShadow **) 0 ;
31008 : int result;
31009 :
31010 : (void)jenv;
31011 : (void)jcls;
31012 : (void)jarg1_;
31013 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31014 : {
31015 : /* %typemap(in) (int object_list_count, GDALRasterBandShadow **poObjects) */
31016 : /* check if is List */
31017 0 : if (jarg2)
31018 : {
31019 0 : arg2 = jenv->GetArrayLength(jarg2);
31020 0 : if (arg2 == 0)
31021 0 : arg3 = NULL;
31022 : else
31023 : {
31024 0 : arg3 = (GDALRasterBandShadow**) malloc(sizeof(GDALRasterBandShadow*) * arg2);
31025 : int i;
31026 0 : for (i=0; i<arg2; i++) {
31027 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
31028 0 : if (obj == NULL)
31029 : {
31030 0 : free (arg3 );
31031 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
31032 0 : return 0;
31033 : }
31034 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Band");
31035 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Band;)J");
31036 0 : arg3[i] = (GDALRasterBandShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
31037 : }
31038 : }
31039 : }
31040 : else
31041 : {
31042 0 : arg2 = 0;
31043 0 : arg3 = NULL;
31044 : }
31045 : }
31046 : {
31047 0 : if (!arg1) {
31048 : {
31049 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31050 : };
31051 : }
31052 : }
31053 0 : result = (int)RegenerateOverviews(arg1,arg2,arg3);
31054 0 : jresult = (jint)result;
31055 : {
31056 : /* %typemap(argout) (int object_list_count, GDALRasterBandShadow **poObjects) */
31057 : }
31058 : {
31059 : /* %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects) */
31060 0 : if (arg3) {
31061 0 : free((void*) arg3);
31062 : }
31063 : }
31064 0 : return jresult;
31065 : }
31066 :
31067 :
31068 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverview_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jobject jarg4) {
31069 0 : jint jresult = 0 ;
31070 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31071 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
31072 0 : char *arg3 = (char *) 0 ;
31073 : GDALProgressFunc arg4 ;
31074 0 : void *arg5 = (void *) 0 ;
31075 : int result;
31076 :
31077 : (void)jenv;
31078 : (void)jcls;
31079 : JavaProgressData sProgressInfo;
31080 0 : sProgressInfo.jenv = jenv;
31081 0 : sProgressInfo.pJavaCallback = NULL;
31082 : (void)jarg1_;
31083 : (void)jarg2_;
31084 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31085 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
31086 0 : arg3 = 0;
31087 0 : if (jarg3) {
31088 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
31089 0 : if (!arg3) return 0;
31090 : }
31091 : {
31092 0 : if ( jarg4 != 0 ) {
31093 0 : sProgressInfo.pJavaCallback = jarg4;
31094 0 : arg4 = JavaProgressProxy;
31095 0 : arg5 = &sProgressInfo;
31096 : }
31097 : else
31098 : {
31099 0 : arg4 = NULL;
31100 0 : arg5 = NULL;
31101 : }
31102 : }
31103 : {
31104 0 : if (!arg1) {
31105 : {
31106 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31107 : };
31108 : }
31109 : }
31110 : {
31111 0 : if (!arg2) {
31112 : {
31113 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31114 : };
31115 : }
31116 : }
31117 0 : result = (int)RegenerateOverview(arg1,arg2,(char const *)arg3,arg4,arg5);
31118 0 : jresult = (jint)result;
31119 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
31120 0 : return jresult;
31121 : }
31122 :
31123 :
31124 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverview_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) {
31125 0 : jint jresult = 0 ;
31126 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31127 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
31128 0 : char *arg3 = (char *) 0 ;
31129 : int result;
31130 :
31131 : (void)jenv;
31132 : (void)jcls;
31133 : (void)jarg1_;
31134 : (void)jarg2_;
31135 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31136 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
31137 0 : arg3 = 0;
31138 0 : if (jarg3) {
31139 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
31140 0 : if (!arg3) return 0;
31141 : }
31142 : {
31143 0 : if (!arg1) {
31144 : {
31145 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31146 : };
31147 : }
31148 : }
31149 : {
31150 0 : if (!arg2) {
31151 : {
31152 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31153 : };
31154 : }
31155 : }
31156 0 : result = (int)RegenerateOverview(arg1,arg2,(char const *)arg3);
31157 0 : jresult = (jint)result;
31158 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
31159 0 : return jresult;
31160 : }
31161 :
31162 :
31163 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_RegenerateOverview_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
31164 0 : jint jresult = 0 ;
31165 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31166 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
31167 : int result;
31168 :
31169 : (void)jenv;
31170 : (void)jcls;
31171 : (void)jarg1_;
31172 : (void)jarg2_;
31173 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31174 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
31175 : {
31176 0 : if (!arg1) {
31177 : {
31178 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31179 : };
31180 : }
31181 : }
31182 : {
31183 0 : if (!arg2) {
31184 : {
31185 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31186 : };
31187 : }
31188 : }
31189 0 : result = (int)RegenerateOverview(arg1,arg2);
31190 0 : jresult = (jint)result;
31191 0 : return jresult;
31192 : }
31193 :
31194 :
31195 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GridCreate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jint jarg10, jint jarg11, jint jarg12, jobject jarg13, jobject jarg15) {
31196 0 : jint jresult = 0 ;
31197 0 : char *arg1 = (char *) 0 ;
31198 : int arg2 ;
31199 0 : double *arg3 = (double *) 0 ;
31200 0 : double *arg4 = (double *) 0 ;
31201 0 : double *arg5 = (double *) 0 ;
31202 : double arg6 ;
31203 : double arg7 ;
31204 : double arg8 ;
31205 : double arg9 ;
31206 : int arg10 ;
31207 : int arg11 ;
31208 : GDALDataType arg12 ;
31209 0 : void *arg13 = (void *) 0 ;
31210 : size_t arg14 ;
31211 : GDALProgressFunc arg15 ;
31212 0 : void *arg16 = (void *) 0 ;
31213 : int xyzLen2 ;
31214 : int result;
31215 :
31216 : (void)jenv;
31217 : (void)jcls;
31218 : JavaProgressData sProgressInfo;
31219 0 : sProgressInfo.jenv = jenv;
31220 0 : sProgressInfo.pJavaCallback = NULL;
31221 0 : arg1 = 0;
31222 0 : if (jarg1) {
31223 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
31224 0 : if (!arg1) return 0;
31225 : }
31226 : {
31227 : /* %typemap(in) ( int nCount, double *x, double *y, double *z ) */
31228 0 : arg2 = (jarg2) ? jenv->GetArrayLength(jarg2) : 0;
31229 0 : xyzLen2 = arg2;
31230 0 : arg3 = (double*)CPLMalloc(arg2 * sizeof(double));
31231 0 : arg4 = (double*)CPLMalloc(arg2 * sizeof(double));
31232 0 : arg5 = (double*)CPLMalloc(arg2 * sizeof(double));
31233 : int i;
31234 0 : for (i=0; i<arg2; i++) {
31235 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg2, i);
31236 0 : if (doubleArray == NULL)
31237 : {
31238 0 : CPLFree (arg3);
31239 0 : CPLFree (arg4);
31240 0 : CPLFree (arg5);
31241 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
31242 0 : return 0;
31243 : }
31244 0 : int nDim = jenv->GetArrayLength(doubleArray);
31245 0 : if (nDim != 2 && nDim != 3)
31246 : {
31247 0 : CPLFree (arg3);
31248 0 : CPLFree (arg4);
31249 0 : CPLFree (arg5);
31250 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "wrong array dimensions");
31251 0 : return 0;
31252 : }
31253 0 : double* pElements = jenv->GetDoubleArrayElements(doubleArray, NULL);
31254 0 : arg3[i] = pElements[0];
31255 0 : arg4[i] = pElements[1];
31256 0 : if (nDim == 3)
31257 0 : arg5[i] = pElements[2];
31258 : else
31259 0 : arg5[i] = 0;
31260 0 : jenv->ReleaseDoubleArrayElements(doubleArray, pElements, JNI_ABORT);
31261 : }
31262 : }
31263 0 : arg6 = (double)jarg6;
31264 0 : arg7 = (double)jarg7;
31265 0 : arg8 = (double)jarg8;
31266 0 : arg9 = (double)jarg9;
31267 0 : arg10 = (int)jarg10;
31268 0 : arg11 = (int)jarg11;
31269 0 : arg12 = (GDALDataType)jarg12;
31270 : {
31271 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
31272 0 : if (jarg13 == 0)
31273 : {
31274 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
31275 0 : return 0;
31276 : }
31277 0 : arg13 = jenv->GetDirectBufferAddress(jarg13);
31278 0 : if (arg13 == NULL)
31279 : {
31280 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
31281 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
31282 0 : return 0;
31283 : }
31284 :
31285 : /* The cast to size_t is actually not that correct, but anyway afterwards */
31286 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
31287 : /* so truncating to INT_MAX is OK */
31288 :
31289 0 : arg14 = (size_t) ((jenv->GetDirectBufferCapacity(jarg13) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg13));
31290 : }
31291 : {
31292 0 : if ( jarg15 != 0 ) {
31293 0 : sProgressInfo.pJavaCallback = jarg15;
31294 0 : arg15 = JavaProgressProxy;
31295 0 : arg16 = &sProgressInfo;
31296 : }
31297 : else
31298 : {
31299 0 : arg15 = NULL;
31300 0 : arg16 = NULL;
31301 : }
31302 : }
31303 0 : result = (int)wrapper_GridCreate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
31304 0 : jresult = (jint)result;
31305 : {
31306 : /* %typemap(argout) ( int nCount, double *x, double *y, double *z ) */
31307 : int i;
31308 0 : for (i=0; i<arg2; i++) {
31309 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg2, i);
31310 0 : int nDim = jenv->GetArrayLength(doubleArray);
31311 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)0, (jsize)1, &arg3[i]);
31312 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)1, (jsize)1, &arg4[i]);
31313 0 : if (nDim == 3)
31314 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)2, (jsize)1, &arg5[i]);
31315 : }
31316 0 : CPLFree(arg3);
31317 0 : CPLFree(arg4);
31318 0 : CPLFree(arg5);
31319 : }
31320 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
31321 0 : return jresult;
31322 : }
31323 :
31324 :
31325 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GridCreate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jint jarg10, jint jarg11, jint jarg12, jobject jarg13) {
31326 0 : jint jresult = 0 ;
31327 0 : char *arg1 = (char *) 0 ;
31328 : int arg2 ;
31329 0 : double *arg3 = (double *) 0 ;
31330 0 : double *arg4 = (double *) 0 ;
31331 0 : double *arg5 = (double *) 0 ;
31332 : double arg6 ;
31333 : double arg7 ;
31334 : double arg8 ;
31335 : double arg9 ;
31336 : int arg10 ;
31337 : int arg11 ;
31338 : GDALDataType arg12 ;
31339 0 : void *arg13 = (void *) 0 ;
31340 : size_t arg14 ;
31341 : int xyzLen2 ;
31342 : int result;
31343 :
31344 : (void)jenv;
31345 : (void)jcls;
31346 0 : arg1 = 0;
31347 0 : if (jarg1) {
31348 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
31349 0 : if (!arg1) return 0;
31350 : }
31351 : {
31352 : /* %typemap(in) ( int nCount, double *x, double *y, double *z ) */
31353 0 : arg2 = (jarg2) ? jenv->GetArrayLength(jarg2) : 0;
31354 0 : xyzLen2 = arg2;
31355 0 : arg3 = (double*)CPLMalloc(arg2 * sizeof(double));
31356 0 : arg4 = (double*)CPLMalloc(arg2 * sizeof(double));
31357 0 : arg5 = (double*)CPLMalloc(arg2 * sizeof(double));
31358 : int i;
31359 0 : for (i=0; i<arg2; i++) {
31360 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg2, i);
31361 0 : if (doubleArray == NULL)
31362 : {
31363 0 : CPLFree (arg3);
31364 0 : CPLFree (arg4);
31365 0 : CPLFree (arg5);
31366 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
31367 0 : return 0;
31368 : }
31369 0 : int nDim = jenv->GetArrayLength(doubleArray);
31370 0 : if (nDim != 2 && nDim != 3)
31371 : {
31372 0 : CPLFree (arg3);
31373 0 : CPLFree (arg4);
31374 0 : CPLFree (arg5);
31375 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "wrong array dimensions");
31376 0 : return 0;
31377 : }
31378 0 : double* pElements = jenv->GetDoubleArrayElements(doubleArray, NULL);
31379 0 : arg3[i] = pElements[0];
31380 0 : arg4[i] = pElements[1];
31381 0 : if (nDim == 3)
31382 0 : arg5[i] = pElements[2];
31383 : else
31384 0 : arg5[i] = 0;
31385 0 : jenv->ReleaseDoubleArrayElements(doubleArray, pElements, JNI_ABORT);
31386 : }
31387 : }
31388 0 : arg6 = (double)jarg6;
31389 0 : arg7 = (double)jarg7;
31390 0 : arg8 = (double)jarg8;
31391 0 : arg9 = (double)jarg9;
31392 0 : arg10 = (int)jarg10;
31393 0 : arg11 = (int)jarg11;
31394 0 : arg12 = (GDALDataType)jarg12;
31395 : {
31396 : /* %typemap(in, numinputs=1) (void * nioBuffer, size_t nioBufferSize) */
31397 0 : if (jarg13 == 0)
31398 : {
31399 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
31400 0 : return 0;
31401 : }
31402 0 : arg13 = jenv->GetDirectBufferAddress(jarg13);
31403 0 : if (arg13 == NULL)
31404 : {
31405 0 : SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
31406 : "Unable to get address of direct buffer. Buffer must be allocated direct.");
31407 0 : return 0;
31408 : }
31409 :
31410 : /* The cast to size_t is actually not that correct, but anyway afterwards */
31411 : /* we check that the theoretical minimum buffer size is not larger than INT_MAX */
31412 : /* so truncating to INT_MAX is OK */
31413 :
31414 0 : arg14 = (size_t) ((jenv->GetDirectBufferCapacity(jarg13) > INT_MAX) ? INT_MAX : jenv->GetDirectBufferCapacity(jarg13));
31415 : }
31416 0 : result = (int)wrapper_GridCreate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
31417 0 : jresult = (jint)result;
31418 : {
31419 : /* %typemap(argout) ( int nCount, double *x, double *y, double *z ) */
31420 : int i;
31421 0 : for (i=0; i<arg2; i++) {
31422 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg2, i);
31423 0 : int nDim = jenv->GetArrayLength(doubleArray);
31424 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)0, (jsize)1, &arg3[i]);
31425 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)1, (jsize)1, &arg4[i]);
31426 0 : if (nDim == 3)
31427 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)2, (jsize)1, &arg5[i]);
31428 : }
31429 0 : CPLFree(arg3);
31430 0 : CPLFree(arg4);
31431 0 : CPLFree(arg5);
31432 : }
31433 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
31434 0 : return jresult;
31435 : }
31436 :
31437 :
31438 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ContourGenerate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jint jarg6, jdouble jarg7, jlong jarg8, jobject jarg8_, jint jarg9, jint jarg10, jobject jarg11) {
31439 1 : jint jresult = 0 ;
31440 1 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31441 : double arg2 ;
31442 : double arg3 ;
31443 : int arg4 ;
31444 1 : double *arg5 = (double *) 0 ;
31445 : int arg6 ;
31446 : double arg7 ;
31447 1 : OGRLayerShadow *arg8 = (OGRLayerShadow *) 0 ;
31448 : int arg9 ;
31449 : int arg10 ;
31450 : GDALProgressFunc arg11 ;
31451 1 : void *arg12 = (void *) 0 ;
31452 : int result;
31453 :
31454 : (void)jenv;
31455 : (void)jcls;
31456 : JavaProgressData sProgressInfo;
31457 1 : sProgressInfo.jenv = jenv;
31458 1 : sProgressInfo.pJavaCallback = NULL;
31459 : (void)jarg1_;
31460 : (void)jarg8_;
31461 1 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31462 1 : arg2 = (double)jarg2;
31463 1 : arg3 = (double)jarg3;
31464 : {
31465 : /* %typemap(in) (int nList, double* pList) */
31466 : /* check if is List */
31467 1 : if (jarg4)
31468 : {
31469 0 : arg4 = jenv->GetArrayLength(jarg4);
31470 0 : if (arg4 == 0)
31471 0 : arg5 = NULL;
31472 : else
31473 0 : arg5 = (double *)jenv->GetDoubleArrayElements(jarg4, NULL);
31474 : }
31475 : else
31476 : {
31477 1 : arg4 = 0;
31478 1 : arg5 = NULL;
31479 : }
31480 : }
31481 1 : arg6 = (int)jarg6;
31482 1 : arg7 = (double)jarg7;
31483 1 : arg8 = *(OGRLayerShadow **)&jarg8;
31484 1 : arg9 = (int)jarg9;
31485 1 : arg10 = (int)jarg10;
31486 : {
31487 1 : if ( jarg11 != 0 ) {
31488 1 : sProgressInfo.pJavaCallback = jarg11;
31489 1 : arg11 = JavaProgressProxy;
31490 1 : arg12 = &sProgressInfo;
31491 : }
31492 : else
31493 : {
31494 0 : arg11 = NULL;
31495 0 : arg12 = NULL;
31496 : }
31497 : }
31498 : {
31499 1 : if (!arg1) {
31500 : {
31501 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31502 : };
31503 : }
31504 : }
31505 : {
31506 1 : if (!arg8) {
31507 : {
31508 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31509 : };
31510 : }
31511 : }
31512 1 : result = (int)ContourGenerate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
31513 1 : jresult = (jint)result;
31514 : {
31515 : /* %typemap(argout) (int nList, double* pList) */
31516 : }
31517 : {
31518 : /* %typemap(freearg) (int nList, double* pList) */
31519 1 : if (arg5) {
31520 0 : jenv->ReleaseDoubleArrayElements(jarg4, arg5, JNI_ABORT);
31521 : }
31522 : }
31523 1 : return jresult;
31524 : }
31525 :
31526 :
31527 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ContourGenerate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jint jarg6, jdouble jarg7, jlong jarg8, jobject jarg8_, jint jarg9, jint jarg10) {
31528 0 : jint jresult = 0 ;
31529 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31530 : double arg2 ;
31531 : double arg3 ;
31532 : int arg4 ;
31533 0 : double *arg5 = (double *) 0 ;
31534 : int arg6 ;
31535 : double arg7 ;
31536 0 : OGRLayerShadow *arg8 = (OGRLayerShadow *) 0 ;
31537 : int arg9 ;
31538 : int arg10 ;
31539 : int result;
31540 :
31541 : (void)jenv;
31542 : (void)jcls;
31543 : (void)jarg1_;
31544 : (void)jarg8_;
31545 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31546 0 : arg2 = (double)jarg2;
31547 0 : arg3 = (double)jarg3;
31548 : {
31549 : /* %typemap(in) (int nList, double* pList) */
31550 : /* check if is List */
31551 0 : if (jarg4)
31552 : {
31553 0 : arg4 = jenv->GetArrayLength(jarg4);
31554 0 : if (arg4 == 0)
31555 0 : arg5 = NULL;
31556 : else
31557 0 : arg5 = (double *)jenv->GetDoubleArrayElements(jarg4, NULL);
31558 : }
31559 : else
31560 : {
31561 0 : arg4 = 0;
31562 0 : arg5 = NULL;
31563 : }
31564 : }
31565 0 : arg6 = (int)jarg6;
31566 0 : arg7 = (double)jarg7;
31567 0 : arg8 = *(OGRLayerShadow **)&jarg8;
31568 0 : arg9 = (int)jarg9;
31569 0 : arg10 = (int)jarg10;
31570 : {
31571 0 : if (!arg1) {
31572 : {
31573 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31574 : };
31575 : }
31576 : }
31577 : {
31578 0 : if (!arg8) {
31579 : {
31580 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31581 : };
31582 : }
31583 : }
31584 0 : result = (int)ContourGenerate(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
31585 0 : jresult = (jint)result;
31586 : {
31587 : /* %typemap(argout) (int nList, double* pList) */
31588 : }
31589 : {
31590 : /* %typemap(freearg) (int nList, double* pList) */
31591 0 : if (arg5) {
31592 0 : jenv->ReleaseDoubleArrayElements(jarg4, arg5, JNI_ABORT);
31593 : }
31594 : }
31595 0 : return jresult;
31596 : }
31597 :
31598 :
31599 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ContourGenerateEx_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3, jobject jarg4) {
31600 0 : jint jresult = 0 ;
31601 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31602 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
31603 0 : char **arg3 = (char **) 0 ;
31604 : GDALProgressFunc arg4 ;
31605 0 : void *arg5 = (void *) 0 ;
31606 : int result;
31607 :
31608 : (void)jenv;
31609 : (void)jcls;
31610 : JavaProgressData sProgressInfo;
31611 0 : sProgressInfo.jenv = jenv;
31612 0 : sProgressInfo.pJavaCallback = NULL;
31613 : (void)jarg1_;
31614 : (void)jarg2_;
31615 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31616 0 : arg2 = *(OGRLayerShadow **)&jarg2;
31617 : {
31618 : /* %typemap(in) char **options */
31619 0 : arg3 = NULL;
31620 0 : if(jarg3 != 0) {
31621 0 : const jclass vector = jenv->FindClass("java/util/Vector");
31622 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
31623 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
31624 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
31625 : "()Ljava/util/Enumeration;");
31626 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
31627 : "hasMoreElements", "()Z");
31628 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
31629 : "nextElement", "()Ljava/lang/Object;");
31630 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
31631 0 : hasMoreElements == NULL || getNextElement == NULL) {
31632 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
31633 0 : return 0;
31634 : }
31635 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
31636 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
31637 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
31638 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
31639 : {
31640 0 : CSLDestroy(arg3);
31641 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
31642 0 : return 0;
31643 : }
31644 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
31645 0 : arg3 = CSLAddString(arg3, valptr);
31646 0 : jenv->ReleaseStringUTFChars(value, valptr);
31647 : }
31648 : }
31649 : }
31650 : {
31651 0 : if ( jarg4 != 0 ) {
31652 0 : sProgressInfo.pJavaCallback = jarg4;
31653 0 : arg4 = JavaProgressProxy;
31654 0 : arg5 = &sProgressInfo;
31655 : }
31656 : else
31657 : {
31658 0 : arg4 = NULL;
31659 0 : arg5 = NULL;
31660 : }
31661 : }
31662 : {
31663 0 : if (!arg1) {
31664 : {
31665 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31666 : };
31667 : }
31668 : }
31669 : {
31670 0 : if (!arg2) {
31671 : {
31672 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31673 : };
31674 : }
31675 : }
31676 0 : result = (int)ContourGenerateEx(arg1,arg2,arg3,arg4,arg5);
31677 0 : jresult = (jint)result;
31678 : {
31679 : /* %typemap(freearg) char **options */
31680 0 : CSLDestroy( arg3 );
31681 : }
31682 0 : return jresult;
31683 : }
31684 :
31685 :
31686 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ContourGenerateEx_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3) {
31687 0 : jint jresult = 0 ;
31688 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31689 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
31690 0 : char **arg3 = (char **) 0 ;
31691 : int result;
31692 :
31693 : (void)jenv;
31694 : (void)jcls;
31695 : (void)jarg1_;
31696 : (void)jarg2_;
31697 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31698 0 : arg2 = *(OGRLayerShadow **)&jarg2;
31699 : {
31700 : /* %typemap(in) char **options */
31701 0 : arg3 = NULL;
31702 0 : if(jarg3 != 0) {
31703 0 : const jclass vector = jenv->FindClass("java/util/Vector");
31704 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
31705 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
31706 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
31707 : "()Ljava/util/Enumeration;");
31708 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
31709 : "hasMoreElements", "()Z");
31710 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
31711 : "nextElement", "()Ljava/lang/Object;");
31712 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
31713 0 : hasMoreElements == NULL || getNextElement == NULL) {
31714 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
31715 0 : return 0;
31716 : }
31717 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
31718 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
31719 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
31720 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
31721 : {
31722 0 : CSLDestroy(arg3);
31723 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
31724 0 : return 0;
31725 : }
31726 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
31727 0 : arg3 = CSLAddString(arg3, valptr);
31728 0 : jenv->ReleaseStringUTFChars(value, valptr);
31729 : }
31730 : }
31731 : }
31732 : {
31733 0 : if (!arg1) {
31734 : {
31735 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31736 : };
31737 : }
31738 : }
31739 : {
31740 0 : if (!arg2) {
31741 : {
31742 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31743 : };
31744 : }
31745 : }
31746 0 : result = (int)ContourGenerateEx(arg1,arg2,arg3);
31747 0 : jresult = (jint)result;
31748 : {
31749 : /* %typemap(freearg) char **options */
31750 0 : CSLDestroy( arg3 );
31751 : }
31752 0 : return jresult;
31753 : }
31754 :
31755 :
31756 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_ContourGenerateEx_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
31757 0 : jint jresult = 0 ;
31758 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31759 0 : OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
31760 : int result;
31761 :
31762 : (void)jenv;
31763 : (void)jcls;
31764 : (void)jarg1_;
31765 : (void)jarg2_;
31766 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31767 0 : arg2 = *(OGRLayerShadow **)&jarg2;
31768 : {
31769 0 : if (!arg1) {
31770 : {
31771 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31772 : };
31773 : }
31774 : }
31775 : {
31776 0 : if (!arg2) {
31777 : {
31778 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
31779 : };
31780 : }
31781 : }
31782 0 : result = (int)ContourGenerateEx(arg1,arg2);
31783 0 : jresult = (jint)result;
31784 0 : return jresult;
31785 : }
31786 :
31787 :
31788 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVM_1Diagonal_1get(JNIEnv *jenv, jclass jcls) {
31789 0 : jint jresult = 0 ;
31790 : GDALViewshedMode result;
31791 :
31792 : (void)jenv;
31793 : (void)jcls;
31794 0 : result = (GDALViewshedMode)GVM_Diagonal;
31795 0 : jresult = (jint)result;
31796 0 : return jresult;
31797 : }
31798 :
31799 :
31800 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVM_1Edge_1get(JNIEnv *jenv, jclass jcls) {
31801 0 : jint jresult = 0 ;
31802 : GDALViewshedMode result;
31803 :
31804 : (void)jenv;
31805 : (void)jcls;
31806 0 : result = (GDALViewshedMode)GVM_Edge;
31807 0 : jresult = (jint)result;
31808 0 : return jresult;
31809 : }
31810 :
31811 :
31812 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVM_1Max_1get(JNIEnv *jenv, jclass jcls) {
31813 0 : jint jresult = 0 ;
31814 : GDALViewshedMode result;
31815 :
31816 : (void)jenv;
31817 : (void)jcls;
31818 0 : result = (GDALViewshedMode)GVM_Max;
31819 0 : jresult = (jint)result;
31820 0 : return jresult;
31821 : }
31822 :
31823 :
31824 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVM_1Min_1get(JNIEnv *jenv, jclass jcls) {
31825 0 : jint jresult = 0 ;
31826 : GDALViewshedMode result;
31827 :
31828 : (void)jenv;
31829 : (void)jcls;
31830 0 : result = (GDALViewshedMode)GVM_Min;
31831 0 : jresult = (jint)result;
31832 0 : return jresult;
31833 : }
31834 :
31835 :
31836 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVOT_1NORMAL_1get(JNIEnv *jenv, jclass jcls) {
31837 0 : jint jresult = 0 ;
31838 : GDALViewshedOutputType result;
31839 :
31840 : (void)jenv;
31841 : (void)jcls;
31842 0 : result = (GDALViewshedOutputType)GVOT_NORMAL;
31843 0 : jresult = (jint)result;
31844 0 : return jresult;
31845 : }
31846 :
31847 :
31848 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVOT_1MIN_1TARGET_1HEIGHT_1FROM_1DEM_1get(JNIEnv *jenv, jclass jcls) {
31849 0 : jint jresult = 0 ;
31850 : GDALViewshedOutputType result;
31851 :
31852 : (void)jenv;
31853 : (void)jcls;
31854 0 : result = (GDALViewshedOutputType)GVOT_MIN_TARGET_HEIGHT_FROM_DEM;
31855 0 : jresult = (jint)result;
31856 0 : return jresult;
31857 : }
31858 :
31859 :
31860 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GVOT_1MIN_1TARGET_1HEIGHT_1FROM_1GROUND_1get(JNIEnv *jenv, jclass jcls) {
31861 0 : jint jresult = 0 ;
31862 : GDALViewshedOutputType result;
31863 :
31864 : (void)jenv;
31865 : (void)jcls;
31866 0 : result = (GDALViewshedOutputType)GVOT_MIN_TARGET_HEIGHT_FROM_GROUND;
31867 0 : jresult = (jint)result;
31868 0 : return jresult;
31869 : }
31870 :
31871 :
31872 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ViewshedGenerate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jdouble jarg12, jdouble jarg13, jint jarg14, jdouble jarg15, jobject jarg16, jint jarg18, jobject jarg19) {
31873 0 : jlong jresult = 0 ;
31874 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
31875 0 : char *arg2 = (char *) 0 ;
31876 0 : char *arg3 = (char *) 0 ;
31877 0 : char **arg4 = (char **) 0 ;
31878 : double arg5 ;
31879 : double arg6 ;
31880 : double arg7 ;
31881 : double arg8 ;
31882 : double arg9 ;
31883 : double arg10 ;
31884 : double arg11 ;
31885 : double arg12 ;
31886 : double arg13 ;
31887 : GDALViewshedMode arg14 ;
31888 : double arg15 ;
31889 : GDALProgressFunc arg16 ;
31890 0 : void *arg17 = (void *) 0 ;
31891 : GDALViewshedOutputType arg18 ;
31892 0 : char **arg19 = (char **) 0 ;
31893 0 : GDALDatasetShadow *result = 0 ;
31894 :
31895 : (void)jenv;
31896 : (void)jcls;
31897 : JavaProgressData sProgressInfo;
31898 0 : sProgressInfo.jenv = jenv;
31899 0 : sProgressInfo.pJavaCallback = NULL;
31900 : (void)jarg1_;
31901 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
31902 0 : arg2 = 0;
31903 0 : if (jarg2) {
31904 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
31905 0 : if (!arg2) return 0;
31906 : }
31907 0 : arg3 = 0;
31908 0 : if (jarg3) {
31909 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
31910 0 : if (!arg3) return 0;
31911 : }
31912 : {
31913 : /* %typemap(in) char **options */
31914 0 : arg4 = NULL;
31915 0 : if(jarg4 != 0) {
31916 0 : const jclass vector = jenv->FindClass("java/util/Vector");
31917 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
31918 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
31919 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
31920 : "()Ljava/util/Enumeration;");
31921 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
31922 : "hasMoreElements", "()Z");
31923 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
31924 : "nextElement", "()Ljava/lang/Object;");
31925 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
31926 0 : hasMoreElements == NULL || getNextElement == NULL) {
31927 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
31928 0 : return 0;
31929 : }
31930 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
31931 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
31932 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
31933 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
31934 : {
31935 0 : CSLDestroy(arg4);
31936 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
31937 0 : return 0;
31938 : }
31939 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
31940 0 : arg4 = CSLAddString(arg4, valptr);
31941 0 : jenv->ReleaseStringUTFChars(value, valptr);
31942 : }
31943 : }
31944 : }
31945 0 : arg5 = (double)jarg5;
31946 0 : arg6 = (double)jarg6;
31947 0 : arg7 = (double)jarg7;
31948 0 : arg8 = (double)jarg8;
31949 0 : arg9 = (double)jarg9;
31950 0 : arg10 = (double)jarg10;
31951 0 : arg11 = (double)jarg11;
31952 0 : arg12 = (double)jarg12;
31953 0 : arg13 = (double)jarg13;
31954 0 : arg14 = (GDALViewshedMode)jarg14;
31955 0 : arg15 = (double)jarg15;
31956 : {
31957 0 : if ( jarg16 != 0 ) {
31958 0 : sProgressInfo.pJavaCallback = jarg16;
31959 0 : arg16 = JavaProgressProxy;
31960 0 : arg17 = &sProgressInfo;
31961 : }
31962 : else
31963 : {
31964 0 : arg16 = NULL;
31965 0 : arg17 = NULL;
31966 : }
31967 : }
31968 0 : arg18 = (GDALViewshedOutputType)jarg18;
31969 : {
31970 : /* %typemap(in) char **options */
31971 0 : arg19 = NULL;
31972 0 : if(jarg19 != 0) {
31973 0 : const jclass vector = jenv->FindClass("java/util/Vector");
31974 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
31975 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
31976 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
31977 : "()Ljava/util/Enumeration;");
31978 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
31979 : "hasMoreElements", "()Z");
31980 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
31981 : "nextElement", "()Ljava/lang/Object;");
31982 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
31983 0 : hasMoreElements == NULL || getNextElement == NULL) {
31984 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
31985 0 : return 0;
31986 : }
31987 0 : for (jobject keys = jenv->CallObjectMethod(jarg19, elements);
31988 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
31989 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
31990 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
31991 : {
31992 0 : CSLDestroy(arg19);
31993 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
31994 0 : return 0;
31995 : }
31996 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
31997 0 : arg19 = CSLAddString(arg19, valptr);
31998 0 : jenv->ReleaseStringUTFChars(value, valptr);
31999 : }
32000 : }
32001 : }
32002 : {
32003 0 : if (!arg1) {
32004 : {
32005 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32006 : };
32007 : }
32008 : }
32009 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);
32010 0 : *(GDALDatasetShadow **)&jresult = result;
32011 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32012 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32013 : {
32014 : /* %typemap(freearg) char **options */
32015 0 : CSLDestroy( arg4 );
32016 : }
32017 : {
32018 : /* %typemap(freearg) char **options */
32019 0 : CSLDestroy( arg19 );
32020 : }
32021 0 : return jresult;
32022 : }
32023 :
32024 :
32025 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ViewshedGenerate_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jdouble jarg12, jdouble jarg13, jint jarg14, jdouble jarg15, jobject jarg16, jint jarg18) {
32026 0 : jlong jresult = 0 ;
32027 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
32028 0 : char *arg2 = (char *) 0 ;
32029 0 : char *arg3 = (char *) 0 ;
32030 0 : char **arg4 = (char **) 0 ;
32031 : double arg5 ;
32032 : double arg6 ;
32033 : double arg7 ;
32034 : double arg8 ;
32035 : double arg9 ;
32036 : double arg10 ;
32037 : double arg11 ;
32038 : double arg12 ;
32039 : double arg13 ;
32040 : GDALViewshedMode arg14 ;
32041 : double arg15 ;
32042 : GDALProgressFunc arg16 ;
32043 0 : void *arg17 = (void *) 0 ;
32044 : GDALViewshedOutputType arg18 ;
32045 0 : GDALDatasetShadow *result = 0 ;
32046 :
32047 : (void)jenv;
32048 : (void)jcls;
32049 : JavaProgressData sProgressInfo;
32050 0 : sProgressInfo.jenv = jenv;
32051 0 : sProgressInfo.pJavaCallback = NULL;
32052 : (void)jarg1_;
32053 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
32054 0 : arg2 = 0;
32055 0 : if (jarg2) {
32056 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32057 0 : if (!arg2) return 0;
32058 : }
32059 0 : arg3 = 0;
32060 0 : if (jarg3) {
32061 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32062 0 : if (!arg3) return 0;
32063 : }
32064 : {
32065 : /* %typemap(in) char **options */
32066 0 : arg4 = NULL;
32067 0 : if(jarg4 != 0) {
32068 0 : const jclass vector = jenv->FindClass("java/util/Vector");
32069 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
32070 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
32071 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
32072 : "()Ljava/util/Enumeration;");
32073 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
32074 : "hasMoreElements", "()Z");
32075 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
32076 : "nextElement", "()Ljava/lang/Object;");
32077 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
32078 0 : hasMoreElements == NULL || getNextElement == NULL) {
32079 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
32080 0 : return 0;
32081 : }
32082 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
32083 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
32084 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
32085 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
32086 : {
32087 0 : CSLDestroy(arg4);
32088 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
32089 0 : return 0;
32090 : }
32091 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
32092 0 : arg4 = CSLAddString(arg4, valptr);
32093 0 : jenv->ReleaseStringUTFChars(value, valptr);
32094 : }
32095 : }
32096 : }
32097 0 : arg5 = (double)jarg5;
32098 0 : arg6 = (double)jarg6;
32099 0 : arg7 = (double)jarg7;
32100 0 : arg8 = (double)jarg8;
32101 0 : arg9 = (double)jarg9;
32102 0 : arg10 = (double)jarg10;
32103 0 : arg11 = (double)jarg11;
32104 0 : arg12 = (double)jarg12;
32105 0 : arg13 = (double)jarg13;
32106 0 : arg14 = (GDALViewshedMode)jarg14;
32107 0 : arg15 = (double)jarg15;
32108 : {
32109 0 : if ( jarg16 != 0 ) {
32110 0 : sProgressInfo.pJavaCallback = jarg16;
32111 0 : arg16 = JavaProgressProxy;
32112 0 : arg17 = &sProgressInfo;
32113 : }
32114 : else
32115 : {
32116 0 : arg16 = NULL;
32117 0 : arg17 = NULL;
32118 : }
32119 : }
32120 0 : arg18 = (GDALViewshedOutputType)jarg18;
32121 : {
32122 0 : if (!arg1) {
32123 : {
32124 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32125 : };
32126 : }
32127 : }
32128 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);
32129 0 : *(GDALDatasetShadow **)&jresult = result;
32130 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32131 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32132 : {
32133 : /* %typemap(freearg) char **options */
32134 0 : CSLDestroy( arg4 );
32135 : }
32136 0 : return jresult;
32137 : }
32138 :
32139 :
32140 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ViewshedGenerate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jdouble jarg12, jdouble jarg13, jint jarg14, jdouble jarg15, jobject jarg16) {
32141 0 : jlong jresult = 0 ;
32142 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
32143 0 : char *arg2 = (char *) 0 ;
32144 0 : char *arg3 = (char *) 0 ;
32145 0 : char **arg4 = (char **) 0 ;
32146 : double arg5 ;
32147 : double arg6 ;
32148 : double arg7 ;
32149 : double arg8 ;
32150 : double arg9 ;
32151 : double arg10 ;
32152 : double arg11 ;
32153 : double arg12 ;
32154 : double arg13 ;
32155 : GDALViewshedMode arg14 ;
32156 : double arg15 ;
32157 : GDALProgressFunc arg16 ;
32158 0 : void *arg17 = (void *) 0 ;
32159 0 : GDALDatasetShadow *result = 0 ;
32160 :
32161 : (void)jenv;
32162 : (void)jcls;
32163 : JavaProgressData sProgressInfo;
32164 0 : sProgressInfo.jenv = jenv;
32165 0 : sProgressInfo.pJavaCallback = NULL;
32166 : (void)jarg1_;
32167 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
32168 0 : arg2 = 0;
32169 0 : if (jarg2) {
32170 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32171 0 : if (!arg2) return 0;
32172 : }
32173 0 : arg3 = 0;
32174 0 : if (jarg3) {
32175 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32176 0 : if (!arg3) return 0;
32177 : }
32178 : {
32179 : /* %typemap(in) char **options */
32180 0 : arg4 = NULL;
32181 0 : if(jarg4 != 0) {
32182 0 : const jclass vector = jenv->FindClass("java/util/Vector");
32183 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
32184 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
32185 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
32186 : "()Ljava/util/Enumeration;");
32187 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
32188 : "hasMoreElements", "()Z");
32189 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
32190 : "nextElement", "()Ljava/lang/Object;");
32191 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
32192 0 : hasMoreElements == NULL || getNextElement == NULL) {
32193 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
32194 0 : return 0;
32195 : }
32196 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
32197 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
32198 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
32199 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
32200 : {
32201 0 : CSLDestroy(arg4);
32202 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
32203 0 : return 0;
32204 : }
32205 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
32206 0 : arg4 = CSLAddString(arg4, valptr);
32207 0 : jenv->ReleaseStringUTFChars(value, valptr);
32208 : }
32209 : }
32210 : }
32211 0 : arg5 = (double)jarg5;
32212 0 : arg6 = (double)jarg6;
32213 0 : arg7 = (double)jarg7;
32214 0 : arg8 = (double)jarg8;
32215 0 : arg9 = (double)jarg9;
32216 0 : arg10 = (double)jarg10;
32217 0 : arg11 = (double)jarg11;
32218 0 : arg12 = (double)jarg12;
32219 0 : arg13 = (double)jarg13;
32220 0 : arg14 = (GDALViewshedMode)jarg14;
32221 0 : arg15 = (double)jarg15;
32222 : {
32223 0 : if ( jarg16 != 0 ) {
32224 0 : sProgressInfo.pJavaCallback = jarg16;
32225 0 : arg16 = JavaProgressProxy;
32226 0 : arg17 = &sProgressInfo;
32227 : }
32228 : else
32229 : {
32230 0 : arg16 = NULL;
32231 0 : arg17 = NULL;
32232 : }
32233 : }
32234 : {
32235 0 : if (!arg1) {
32236 : {
32237 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32238 : };
32239 : }
32240 : }
32241 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);
32242 0 : *(GDALDatasetShadow **)&jresult = result;
32243 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32244 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32245 : {
32246 : /* %typemap(freearg) char **options */
32247 0 : CSLDestroy( arg4 );
32248 : }
32249 0 : return jresult;
32250 : }
32251 :
32252 :
32253 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ViewshedGenerate_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jobject jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11, jdouble jarg12, jdouble jarg13, jint jarg14, jdouble jarg15) {
32254 0 : jlong jresult = 0 ;
32255 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
32256 0 : char *arg2 = (char *) 0 ;
32257 0 : char *arg3 = (char *) 0 ;
32258 0 : char **arg4 = (char **) 0 ;
32259 : double arg5 ;
32260 : double arg6 ;
32261 : double arg7 ;
32262 : double arg8 ;
32263 : double arg9 ;
32264 : double arg10 ;
32265 : double arg11 ;
32266 : double arg12 ;
32267 : double arg13 ;
32268 : GDALViewshedMode arg14 ;
32269 : double arg15 ;
32270 0 : GDALDatasetShadow *result = 0 ;
32271 :
32272 : (void)jenv;
32273 : (void)jcls;
32274 : (void)jarg1_;
32275 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
32276 0 : arg2 = 0;
32277 0 : if (jarg2) {
32278 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32279 0 : if (!arg2) return 0;
32280 : }
32281 0 : arg3 = 0;
32282 0 : if (jarg3) {
32283 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32284 0 : if (!arg3) return 0;
32285 : }
32286 : {
32287 : /* %typemap(in) char **options */
32288 0 : arg4 = NULL;
32289 0 : if(jarg4 != 0) {
32290 0 : const jclass vector = jenv->FindClass("java/util/Vector");
32291 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
32292 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
32293 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
32294 : "()Ljava/util/Enumeration;");
32295 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
32296 : "hasMoreElements", "()Z");
32297 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
32298 : "nextElement", "()Ljava/lang/Object;");
32299 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
32300 0 : hasMoreElements == NULL || getNextElement == NULL) {
32301 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
32302 0 : return 0;
32303 : }
32304 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
32305 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
32306 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
32307 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
32308 : {
32309 0 : CSLDestroy(arg4);
32310 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
32311 0 : return 0;
32312 : }
32313 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
32314 0 : arg4 = CSLAddString(arg4, valptr);
32315 0 : jenv->ReleaseStringUTFChars(value, valptr);
32316 : }
32317 : }
32318 : }
32319 0 : arg5 = (double)jarg5;
32320 0 : arg6 = (double)jarg6;
32321 0 : arg7 = (double)jarg7;
32322 0 : arg8 = (double)jarg8;
32323 0 : arg9 = (double)jarg9;
32324 0 : arg10 = (double)jarg10;
32325 0 : arg11 = (double)jarg11;
32326 0 : arg12 = (double)jarg12;
32327 0 : arg13 = (double)jarg13;
32328 0 : arg14 = (GDALViewshedMode)jarg14;
32329 0 : arg15 = (double)jarg15;
32330 : {
32331 0 : if (!arg1) {
32332 : {
32333 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32334 : };
32335 : }
32336 : }
32337 0 : result = (GDALDatasetShadow *)ViewshedGenerate(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15);
32338 0 : *(GDALDatasetShadow **)&jresult = result;
32339 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32340 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32341 : {
32342 : /* %typemap(freearg) char **options */
32343 0 : CSLDestroy( arg4 );
32344 : }
32345 0 : return jresult;
32346 : }
32347 :
32348 :
32349 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_IsLineOfSightVisible_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jdouble jarg4, jint jarg5, jint jarg6, jdouble jarg7, jobject jarg8) {
32350 0 : jboolean jresult = 0 ;
32351 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
32352 : int arg2 ;
32353 : int arg3 ;
32354 : double arg4 ;
32355 : int arg5 ;
32356 : int arg6 ;
32357 : double arg7 ;
32358 0 : char **arg8 = (char **) 0 ;
32359 : bool result;
32360 :
32361 : (void)jenv;
32362 : (void)jcls;
32363 : (void)jarg1_;
32364 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
32365 0 : arg2 = (int)jarg2;
32366 0 : arg3 = (int)jarg3;
32367 0 : arg4 = (double)jarg4;
32368 0 : arg5 = (int)jarg5;
32369 0 : arg6 = (int)jarg6;
32370 0 : arg7 = (double)jarg7;
32371 : {
32372 : /* %typemap(in) char **options */
32373 0 : arg8 = NULL;
32374 0 : if(jarg8 != 0) {
32375 0 : const jclass vector = jenv->FindClass("java/util/Vector");
32376 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
32377 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
32378 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
32379 : "()Ljava/util/Enumeration;");
32380 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
32381 : "hasMoreElements", "()Z");
32382 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
32383 : "nextElement", "()Ljava/lang/Object;");
32384 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
32385 0 : hasMoreElements == NULL || getNextElement == NULL) {
32386 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
32387 0 : return 0;
32388 : }
32389 0 : for (jobject keys = jenv->CallObjectMethod(jarg8, elements);
32390 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
32391 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
32392 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
32393 : {
32394 0 : CSLDestroy(arg8);
32395 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
32396 0 : return 0;
32397 : }
32398 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
32399 0 : arg8 = CSLAddString(arg8, valptr);
32400 0 : jenv->ReleaseStringUTFChars(value, valptr);
32401 : }
32402 : }
32403 : }
32404 : {
32405 0 : if (!arg1) {
32406 : {
32407 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32408 : };
32409 : }
32410 : }
32411 0 : result = (bool)IsLineOfSightVisible(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
32412 0 : jresult = (jboolean)result;
32413 : {
32414 : /* %typemap(freearg) char **options */
32415 0 : CSLDestroy( arg8 );
32416 : }
32417 0 : return jresult;
32418 : }
32419 :
32420 :
32421 0 : SWIGEXPORT jboolean JNICALL Java_org_gdal_gdal_gdalJNI_IsLineOfSightVisible_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jdouble jarg4, jint jarg5, jint jarg6, jdouble jarg7) {
32422 0 : jboolean jresult = 0 ;
32423 0 : GDALRasterBandShadow *arg1 = (GDALRasterBandShadow *) 0 ;
32424 : int arg2 ;
32425 : int arg3 ;
32426 : double arg4 ;
32427 : int arg5 ;
32428 : int arg6 ;
32429 : double arg7 ;
32430 : bool result;
32431 :
32432 : (void)jenv;
32433 : (void)jcls;
32434 : (void)jarg1_;
32435 0 : arg1 = *(GDALRasterBandShadow **)&jarg1;
32436 0 : arg2 = (int)jarg2;
32437 0 : arg3 = (int)jarg3;
32438 0 : arg4 = (double)jarg4;
32439 0 : arg5 = (int)jarg5;
32440 0 : arg6 = (int)jarg6;
32441 0 : arg7 = (double)jarg7;
32442 : {
32443 0 : if (!arg1) {
32444 : {
32445 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32446 : };
32447 : }
32448 : }
32449 0 : result = (bool)IsLineOfSightVisible(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
32450 0 : jresult = (jboolean)result;
32451 0 : return jresult;
32452 : }
32453 :
32454 :
32455 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_AutoCreateWarpedVRT_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jint jarg4, jdouble jarg5) {
32456 0 : jlong jresult = 0 ;
32457 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32458 0 : char *arg2 = (char *) 0 ;
32459 0 : char *arg3 = (char *) 0 ;
32460 : GDALResampleAlg arg4 ;
32461 : double arg5 ;
32462 0 : GDALDatasetShadow *result = 0 ;
32463 :
32464 : (void)jenv;
32465 : (void)jcls;
32466 : (void)jarg1_;
32467 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32468 0 : arg2 = 0;
32469 0 : if (jarg2) {
32470 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32471 0 : if (!arg2) return 0;
32472 : }
32473 0 : arg3 = 0;
32474 0 : if (jarg3) {
32475 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32476 0 : if (!arg3) return 0;
32477 : }
32478 0 : arg4 = (GDALResampleAlg)jarg4;
32479 0 : arg5 = (double)jarg5;
32480 : {
32481 0 : if (!arg1) {
32482 : {
32483 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32484 : };
32485 : }
32486 : }
32487 0 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
32488 0 : *(GDALDatasetShadow **)&jresult = result;
32489 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32490 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32491 0 : return jresult;
32492 : }
32493 :
32494 :
32495 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_AutoCreateWarpedVRT_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jint jarg4) {
32496 0 : jlong jresult = 0 ;
32497 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32498 0 : char *arg2 = (char *) 0 ;
32499 0 : char *arg3 = (char *) 0 ;
32500 : GDALResampleAlg arg4 ;
32501 0 : GDALDatasetShadow *result = 0 ;
32502 :
32503 : (void)jenv;
32504 : (void)jcls;
32505 : (void)jarg1_;
32506 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32507 0 : arg2 = 0;
32508 0 : if (jarg2) {
32509 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32510 0 : if (!arg2) return 0;
32511 : }
32512 0 : arg3 = 0;
32513 0 : if (jarg3) {
32514 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32515 0 : if (!arg3) return 0;
32516 : }
32517 0 : arg4 = (GDALResampleAlg)jarg4;
32518 : {
32519 0 : if (!arg1) {
32520 : {
32521 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32522 : };
32523 : }
32524 : }
32525 0 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1,(char const *)arg2,(char const *)arg3,arg4);
32526 0 : *(GDALDatasetShadow **)&jresult = result;
32527 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32528 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32529 0 : return jresult;
32530 : }
32531 :
32532 :
32533 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_AutoCreateWarpedVRT_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
32534 0 : jlong jresult = 0 ;
32535 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32536 0 : char *arg2 = (char *) 0 ;
32537 0 : char *arg3 = (char *) 0 ;
32538 0 : GDALDatasetShadow *result = 0 ;
32539 :
32540 : (void)jenv;
32541 : (void)jcls;
32542 : (void)jarg1_;
32543 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32544 0 : arg2 = 0;
32545 0 : if (jarg2) {
32546 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32547 0 : if (!arg2) return 0;
32548 : }
32549 0 : arg3 = 0;
32550 0 : if (jarg3) {
32551 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
32552 0 : if (!arg3) return 0;
32553 : }
32554 : {
32555 0 : if (!arg1) {
32556 : {
32557 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32558 : };
32559 : }
32560 : }
32561 0 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1,(char const *)arg2,(char const *)arg3);
32562 0 : *(GDALDatasetShadow **)&jresult = result;
32563 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32564 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
32565 0 : return jresult;
32566 : }
32567 :
32568 :
32569 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_AutoCreateWarpedVRT_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
32570 0 : jlong jresult = 0 ;
32571 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32572 0 : char *arg2 = (char *) 0 ;
32573 0 : GDALDatasetShadow *result = 0 ;
32574 :
32575 : (void)jenv;
32576 : (void)jcls;
32577 : (void)jarg1_;
32578 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32579 0 : arg2 = 0;
32580 0 : if (jarg2) {
32581 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
32582 0 : if (!arg2) return 0;
32583 : }
32584 : {
32585 0 : if (!arg1) {
32586 : {
32587 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32588 : };
32589 : }
32590 : }
32591 0 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1,(char const *)arg2);
32592 0 : *(GDALDatasetShadow **)&jresult = result;
32593 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
32594 0 : return jresult;
32595 : }
32596 :
32597 :
32598 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_AutoCreateWarpedVRT_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
32599 0 : jlong jresult = 0 ;
32600 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32601 0 : GDALDatasetShadow *result = 0 ;
32602 :
32603 : (void)jenv;
32604 : (void)jcls;
32605 : (void)jarg1_;
32606 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32607 : {
32608 0 : if (!arg1) {
32609 : {
32610 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32611 : };
32612 : }
32613 : }
32614 0 : result = (GDALDatasetShadow *)AutoCreateWarpedVRT(arg1);
32615 0 : *(GDALDatasetShadow **)&jresult = result;
32616 0 : return jresult;
32617 : }
32618 :
32619 :
32620 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_CreatePansharpenedVRT(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jobjectArray jarg3) {
32621 0 : jlong jresult = 0 ;
32622 0 : char *arg1 = (char *) 0 ;
32623 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
32624 : int arg3 ;
32625 0 : GDALRasterBandShadow **arg4 = (GDALRasterBandShadow **) 0 ;
32626 0 : GDALDatasetShadow *result = 0 ;
32627 :
32628 : (void)jenv;
32629 : (void)jcls;
32630 : (void)jarg2_;
32631 0 : arg1 = 0;
32632 0 : if (jarg1) {
32633 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
32634 0 : if (!arg1) return 0;
32635 : }
32636 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
32637 : {
32638 : /* %typemap(in) (int object_list_count, GDALRasterBandShadow **poObjects) */
32639 : /* check if is List */
32640 0 : if (jarg3)
32641 : {
32642 0 : arg3 = jenv->GetArrayLength(jarg3);
32643 0 : if (arg3 == 0)
32644 0 : arg4 = NULL;
32645 : else
32646 : {
32647 0 : arg4 = (GDALRasterBandShadow**) malloc(sizeof(GDALRasterBandShadow*) * arg3);
32648 : int i;
32649 0 : for (i=0; i<arg3; i++) {
32650 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg3, i);
32651 0 : if (obj == NULL)
32652 : {
32653 0 : free (arg4 );
32654 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
32655 0 : return 0;
32656 : }
32657 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Band");
32658 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Band;)J");
32659 0 : arg4[i] = (GDALRasterBandShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
32660 : }
32661 : }
32662 : }
32663 : else
32664 : {
32665 0 : arg3 = 0;
32666 0 : arg4 = NULL;
32667 : }
32668 : }
32669 : {
32670 0 : if (!arg2) {
32671 : {
32672 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
32673 : };
32674 : }
32675 : }
32676 0 : result = (GDALDatasetShadow *)CreatePansharpenedVRT((char const *)arg1,arg2,arg3,arg4);
32677 0 : *(GDALDatasetShadow **)&jresult = result;
32678 : {
32679 : /* %typemap(argout) (int object_list_count, GDALRasterBandShadow **poObjects) */
32680 : }
32681 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
32682 : {
32683 : /* %typemap(freearg) (int object_list_count, GDALRasterBandShadow **poObjects) */
32684 0 : if (arg4) {
32685 0 : free((void*) arg4);
32686 : }
32687 : }
32688 0 : return jresult;
32689 : }
32690 :
32691 :
32692 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1Transformer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jobject jarg3) {
32693 0 : jlong jresult = 0 ;
32694 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
32695 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
32696 0 : char **arg3 = (char **) 0 ;
32697 0 : GDALTransformerInfoShadow *result = 0 ;
32698 :
32699 : (void)jenv;
32700 : (void)jcls;
32701 : (void)jarg1_;
32702 : (void)jarg2_;
32703 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
32704 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
32705 : {
32706 : /* %typemap(in) char **options */
32707 0 : arg3 = NULL;
32708 0 : if(jarg3 != 0) {
32709 0 : const jclass vector = jenv->FindClass("java/util/Vector");
32710 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
32711 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
32712 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
32713 : "()Ljava/util/Enumeration;");
32714 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
32715 : "hasMoreElements", "()Z");
32716 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
32717 : "nextElement", "()Ljava/lang/Object;");
32718 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
32719 0 : hasMoreElements == NULL || getNextElement == NULL) {
32720 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
32721 0 : return 0;
32722 : }
32723 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
32724 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
32725 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
32726 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
32727 : {
32728 0 : CSLDestroy(arg3);
32729 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
32730 0 : return 0;
32731 : }
32732 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
32733 0 : arg3 = CSLAddString(arg3, valptr);
32734 0 : jenv->ReleaseStringUTFChars(value, valptr);
32735 : }
32736 : }
32737 : }
32738 0 : result = (GDALTransformerInfoShadow *)new_GDALTransformerInfoShadow(arg1,arg2,arg3);
32739 0 : *(GDALTransformerInfoShadow **)&jresult = result;
32740 : {
32741 : /* %typemap(freearg) char **options */
32742 0 : CSLDestroy( arg3 );
32743 : }
32744 0 : return jresult;
32745 : }
32746 :
32747 :
32748 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1Transformer(JNIEnv *jenv, jclass jcls, jlong jarg1) {
32749 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32750 :
32751 : (void)jenv;
32752 : (void)jcls;
32753 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32754 0 : delete_GDALTransformerInfoShadow(arg1);
32755 0 : }
32756 :
32757 :
32758 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformPoint_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jdoubleArray jarg3) {
32759 0 : jint jresult = 0 ;
32760 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32761 : int arg2 ;
32762 : double *arg3 ;
32763 : int result;
32764 :
32765 : (void)jenv;
32766 : (void)jcls;
32767 : (void)jarg1_;
32768 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32769 0 : arg2 = (int)jarg2;
32770 : {
32771 : /* %typemap(in) (double argout[ANY]) */
32772 0 : if(jarg3 == NULL || jenv->GetArrayLength(jarg3) != 3) {
32773 : char errorMsg[512];
32774 0 : sprintf(errorMsg, "array of size %d expected", 3);
32775 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
32776 0 : return 0;
32777 : }
32778 0 : arg3 = (double *)jenv->GetDoubleArrayElements(jarg3, NULL);
32779 : }
32780 0 : result = (int)GDALTransformerInfoShadow_TransformPoint__SWIG_0(arg1,arg2,arg3);
32781 0 : jresult = (jint)result;
32782 : {
32783 : /* %typemap(argout) (double argout[ANY]) */
32784 : }
32785 : {
32786 : /* %typemap(freearg) (double argout[ANY]) */
32787 0 : jenv->ReleaseDoubleArrayElements(jarg3, (jdouble *)arg3, 0);
32788 : }
32789 0 : return jresult;
32790 : }
32791 :
32792 :
32793 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformPoint_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jint jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6) {
32794 0 : jint jresult = 0 ;
32795 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32796 : double *arg2 ;
32797 : int arg3 ;
32798 : double arg4 ;
32799 : double arg5 ;
32800 : double arg6 ;
32801 : int result;
32802 :
32803 : (void)jenv;
32804 : (void)jcls;
32805 : (void)jarg1_;
32806 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32807 : {
32808 : /* %typemap(in) (double argout[ANY]) */
32809 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 3) {
32810 : char errorMsg[512];
32811 0 : sprintf(errorMsg, "array of size %d expected", 3);
32812 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
32813 0 : return 0;
32814 : }
32815 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
32816 : }
32817 0 : arg3 = (int)jarg3;
32818 0 : arg4 = (double)jarg4;
32819 0 : arg5 = (double)jarg5;
32820 0 : arg6 = (double)jarg6;
32821 0 : result = (int)GDALTransformerInfoShadow_TransformPoint__SWIG_1(arg1,arg2,arg3,arg4,arg5,arg6);
32822 0 : jresult = (jint)result;
32823 : {
32824 : /* %typemap(argout) (double argout[ANY]) */
32825 : }
32826 : {
32827 : /* %typemap(freearg) (double argout[ANY]) */
32828 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
32829 : }
32830 0 : return jresult;
32831 : }
32832 :
32833 :
32834 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformPoint_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2, jint jarg3, jdouble jarg4, jdouble jarg5) {
32835 0 : jint jresult = 0 ;
32836 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32837 : double *arg2 ;
32838 : int arg3 ;
32839 : double arg4 ;
32840 : double arg5 ;
32841 : int result;
32842 :
32843 : (void)jenv;
32844 : (void)jcls;
32845 : (void)jarg1_;
32846 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32847 : {
32848 : /* %typemap(in) (double argout[ANY]) */
32849 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 3) {
32850 : char errorMsg[512];
32851 0 : sprintf(errorMsg, "array of size %d expected", 3);
32852 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
32853 0 : return 0;
32854 : }
32855 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
32856 : }
32857 0 : arg3 = (int)jarg3;
32858 0 : arg4 = (double)jarg4;
32859 0 : arg5 = (double)jarg5;
32860 0 : result = (int)GDALTransformerInfoShadow_TransformPoint__SWIG_1(arg1,arg2,arg3,arg4,arg5);
32861 0 : jresult = (jint)result;
32862 : {
32863 : /* %typemap(argout) (double argout[ANY]) */
32864 : }
32865 : {
32866 : /* %typemap(freearg) (double argout[ANY]) */
32867 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
32868 : }
32869 0 : return jresult;
32870 : }
32871 :
32872 :
32873 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformPoints(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jobjectArray jarg3, jintArray jarg7) {
32874 0 : jint jresult = 0 ;
32875 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32876 : int arg2 ;
32877 : int arg3 ;
32878 0 : double *arg4 = (double *) 0 ;
32879 0 : double *arg5 = (double *) 0 ;
32880 0 : double *arg6 = (double *) 0 ;
32881 0 : int *arg7 = (int *) 0 ;
32882 : int xyzLen3 ;
32883 : int result;
32884 :
32885 : (void)jenv;
32886 : (void)jcls;
32887 : (void)jarg1_;
32888 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32889 0 : arg2 = (int)jarg2;
32890 : {
32891 : /* %typemap(in) ( int nCount, double *x, double *y, double *z ) */
32892 0 : arg3 = (jarg3) ? jenv->GetArrayLength(jarg3) : 0;
32893 0 : xyzLen3 = arg3;
32894 0 : arg4 = (double*)CPLMalloc(arg3 * sizeof(double));
32895 0 : arg5 = (double*)CPLMalloc(arg3 * sizeof(double));
32896 0 : arg6 = (double*)CPLMalloc(arg3 * sizeof(double));
32897 : int i;
32898 0 : for (i=0; i<arg3; i++) {
32899 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg3, i);
32900 0 : if (doubleArray == NULL)
32901 : {
32902 0 : CPLFree (arg4);
32903 0 : CPLFree (arg5);
32904 0 : CPLFree (arg6);
32905 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
32906 0 : return 0;
32907 : }
32908 0 : int nDim = jenv->GetArrayLength(doubleArray);
32909 0 : if (nDim != 2 && nDim != 3)
32910 : {
32911 0 : CPLFree (arg4);
32912 0 : CPLFree (arg5);
32913 0 : CPLFree (arg6);
32914 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "wrong array dimensions");
32915 0 : return 0;
32916 : }
32917 0 : double* pElements = jenv->GetDoubleArrayElements(doubleArray, NULL);
32918 0 : arg4[i] = pElements[0];
32919 0 : arg5[i] = pElements[1];
32920 0 : if (nDim == 3)
32921 0 : arg6[i] = pElements[2];
32922 : else
32923 0 : arg6[i] = 0;
32924 0 : jenv->ReleaseDoubleArrayElements(doubleArray, pElements, JNI_ABORT);
32925 : }
32926 : }
32927 : {
32928 : /* %typemap(in) ( int *panSuccess ) */
32929 0 : if (jarg7 == NULL)
32930 : {
32931 0 : arg7 = (int*)CPLCalloc(xyzLen3, sizeof(int));
32932 : }
32933 : else
32934 : {
32935 0 : int len = jenv->GetArrayLength(jarg7);
32936 : /* HACK */
32937 0 : if (len != xyzLen3)
32938 : {
32939 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "wrong array dimensions");
32940 0 : return 0;
32941 : }
32942 0 : arg7 = (int*)CPLCalloc(len, sizeof(int));
32943 : }
32944 : }
32945 0 : result = (int)GDALTransformerInfoShadow_TransformPoints(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
32946 0 : jresult = (jint)result;
32947 : {
32948 : /* %typemap(argout) ( int nCount, double *x, double *y, double *z ) */
32949 : int i;
32950 0 : for (i=0; i<arg3; i++) {
32951 0 : jdoubleArray doubleArray = (jdoubleArray)jenv->GetObjectArrayElement(jarg3, i);
32952 0 : int nDim = jenv->GetArrayLength(doubleArray);
32953 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)0, (jsize)1, &arg4[i]);
32954 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)1, (jsize)1, &arg5[i]);
32955 0 : if (nDim == 3)
32956 0 : jenv->SetDoubleArrayRegion(doubleArray, (jsize)2, (jsize)1, &arg6[i]);
32957 : }
32958 0 : CPLFree(arg4);
32959 0 : CPLFree(arg5);
32960 0 : CPLFree(arg6);
32961 : }
32962 : {
32963 : /* %typemap(argout) ( int *panSuccess ) */
32964 0 : if (jarg7)
32965 0 : jenv->SetIntArrayRegion(jarg7, (jsize)0, (jsize)xyzLen3, (jint*)arg7);
32966 0 : CPLFree(arg7);
32967 : }
32968 0 : return jresult;
32969 : }
32970 :
32971 :
32972 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformGeolocations_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jobject jarg5, jobject jarg7) {
32973 0 : jint jresult = 0 ;
32974 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
32975 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
32976 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
32977 0 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
32978 : GDALProgressFunc arg5 ;
32979 0 : void *arg6 = (void *) 0 ;
32980 0 : char **arg7 = (char **) 0 ;
32981 : int result;
32982 :
32983 : (void)jenv;
32984 : (void)jcls;
32985 : JavaProgressData sProgressInfo;
32986 0 : sProgressInfo.jenv = jenv;
32987 0 : sProgressInfo.pJavaCallback = NULL;
32988 : (void)jarg1_;
32989 : (void)jarg2_;
32990 : (void)jarg3_;
32991 : (void)jarg4_;
32992 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
32993 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
32994 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
32995 0 : arg4 = *(GDALRasterBandShadow **)&jarg4;
32996 : {
32997 0 : if ( jarg5 != 0 ) {
32998 0 : sProgressInfo.pJavaCallback = jarg5;
32999 0 : arg5 = JavaProgressProxy;
33000 0 : arg6 = &sProgressInfo;
33001 : }
33002 : else
33003 : {
33004 0 : arg5 = NULL;
33005 0 : arg6 = NULL;
33006 : }
33007 : }
33008 : {
33009 : /* %typemap(in) char **options */
33010 0 : arg7 = NULL;
33011 0 : if(jarg7 != 0) {
33012 0 : const jclass vector = jenv->FindClass("java/util/Vector");
33013 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
33014 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
33015 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
33016 : "()Ljava/util/Enumeration;");
33017 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
33018 : "hasMoreElements", "()Z");
33019 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
33020 : "nextElement", "()Ljava/lang/Object;");
33021 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
33022 0 : hasMoreElements == NULL || getNextElement == NULL) {
33023 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
33024 0 : return 0;
33025 : }
33026 0 : for (jobject keys = jenv->CallObjectMethod(jarg7, elements);
33027 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
33028 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
33029 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
33030 : {
33031 0 : CSLDestroy(arg7);
33032 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
33033 0 : return 0;
33034 : }
33035 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
33036 0 : arg7 = CSLAddString(arg7, valptr);
33037 0 : jenv->ReleaseStringUTFChars(value, valptr);
33038 : }
33039 : }
33040 : }
33041 : {
33042 0 : if (!arg2) {
33043 : {
33044 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33045 : };
33046 : }
33047 : }
33048 : {
33049 0 : if (!arg3) {
33050 : {
33051 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33052 : };
33053 : }
33054 : }
33055 : {
33056 0 : if (!arg4) {
33057 : {
33058 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33059 : };
33060 : }
33061 : }
33062 0 : result = (int)GDALTransformerInfoShadow_TransformGeolocations__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
33063 0 : jresult = (jint)result;
33064 : {
33065 : /* %typemap(freearg) char **options */
33066 0 : CSLDestroy( arg7 );
33067 : }
33068 0 : return jresult;
33069 : }
33070 :
33071 :
33072 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformGeolocations_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jobject jarg5) {
33073 0 : jint jresult = 0 ;
33074 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
33075 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
33076 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
33077 0 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
33078 : GDALProgressFunc arg5 ;
33079 0 : void *arg6 = (void *) 0 ;
33080 : int result;
33081 :
33082 : (void)jenv;
33083 : (void)jcls;
33084 : JavaProgressData sProgressInfo;
33085 0 : sProgressInfo.jenv = jenv;
33086 0 : sProgressInfo.pJavaCallback = NULL;
33087 : (void)jarg1_;
33088 : (void)jarg2_;
33089 : (void)jarg3_;
33090 : (void)jarg4_;
33091 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
33092 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
33093 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
33094 0 : arg4 = *(GDALRasterBandShadow **)&jarg4;
33095 : {
33096 0 : if ( jarg5 != 0 ) {
33097 0 : sProgressInfo.pJavaCallback = jarg5;
33098 0 : arg5 = JavaProgressProxy;
33099 0 : arg6 = &sProgressInfo;
33100 : }
33101 : else
33102 : {
33103 0 : arg5 = NULL;
33104 0 : arg6 = NULL;
33105 : }
33106 : }
33107 : {
33108 0 : if (!arg2) {
33109 : {
33110 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33111 : };
33112 : }
33113 : }
33114 : {
33115 0 : if (!arg3) {
33116 : {
33117 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33118 : };
33119 : }
33120 : }
33121 : {
33122 0 : if (!arg4) {
33123 : {
33124 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33125 : };
33126 : }
33127 : }
33128 0 : result = (int)GDALTransformerInfoShadow_TransformGeolocations__SWIG_0(arg1,arg2,arg3,arg4,arg5,arg6);
33129 0 : jresult = (jint)result;
33130 0 : return jresult;
33131 : }
33132 :
33133 :
33134 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Transformer_1TransformGeolocations_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
33135 0 : jint jresult = 0 ;
33136 0 : GDALTransformerInfoShadow *arg1 = (GDALTransformerInfoShadow *) 0 ;
33137 0 : GDALRasterBandShadow *arg2 = (GDALRasterBandShadow *) 0 ;
33138 0 : GDALRasterBandShadow *arg3 = (GDALRasterBandShadow *) 0 ;
33139 0 : GDALRasterBandShadow *arg4 = (GDALRasterBandShadow *) 0 ;
33140 : int result;
33141 :
33142 : (void)jenv;
33143 : (void)jcls;
33144 : (void)jarg1_;
33145 : (void)jarg2_;
33146 : (void)jarg3_;
33147 : (void)jarg4_;
33148 0 : arg1 = *(GDALTransformerInfoShadow **)&jarg1;
33149 0 : arg2 = *(GDALRasterBandShadow **)&jarg2;
33150 0 : arg3 = *(GDALRasterBandShadow **)&jarg3;
33151 0 : arg4 = *(GDALRasterBandShadow **)&jarg4;
33152 : {
33153 0 : if (!arg2) {
33154 : {
33155 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33156 : };
33157 : }
33158 : }
33159 : {
33160 0 : if (!arg3) {
33161 : {
33162 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33163 : };
33164 : }
33165 : }
33166 : {
33167 0 : if (!arg4) {
33168 : {
33169 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33170 : };
33171 : }
33172 : }
33173 0 : result = (int)GDALTransformerInfoShadow_TransformGeolocations__SWIG_0(arg1,arg2,arg3,arg4);
33174 0 : jresult = (jint)result;
33175 0 : return jresult;
33176 : }
33177 :
33178 :
33179 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1width_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33180 0 : jint jresult = 0 ;
33181 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33182 : int result;
33183 :
33184 : (void)jenv;
33185 : (void)jcls;
33186 : (void)jarg1_;
33187 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33188 0 : result = (int) ((arg1)->width);
33189 0 : jresult = (jint)result;
33190 0 : return jresult;
33191 : }
33192 :
33193 :
33194 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1height_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33195 0 : jint jresult = 0 ;
33196 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33197 : int result;
33198 :
33199 : (void)jenv;
33200 : (void)jcls;
33201 : (void)jarg1_;
33202 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33203 0 : result = (int) ((arg1)->height);
33204 0 : jresult = (jint)result;
33205 0 : return jresult;
33206 : }
33207 :
33208 :
33209 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1xmin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33210 0 : jdouble jresult = 0 ;
33211 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33212 : double result;
33213 :
33214 : (void)jenv;
33215 : (void)jcls;
33216 : (void)jarg1_;
33217 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33218 0 : result = (double) ((arg1)->xmin);
33219 0 : jresult = (jdouble)result;
33220 0 : return jresult;
33221 : }
33222 :
33223 :
33224 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1ymin_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33225 0 : jdouble jresult = 0 ;
33226 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33227 : double result;
33228 :
33229 : (void)jenv;
33230 : (void)jcls;
33231 : (void)jarg1_;
33232 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33233 0 : result = (double) ((arg1)->ymin);
33234 0 : jresult = (jdouble)result;
33235 0 : return jresult;
33236 : }
33237 :
33238 :
33239 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1xmax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33240 0 : jdouble jresult = 0 ;
33241 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33242 : double result;
33243 :
33244 : (void)jenv;
33245 : (void)jcls;
33246 : (void)jarg1_;
33247 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33248 0 : result = (double) ((arg1)->xmax);
33249 0 : jresult = (jdouble)result;
33250 0 : return jresult;
33251 : }
33252 :
33253 :
33254 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1ymax_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33255 0 : jdouble jresult = 0 ;
33256 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33257 : double result;
33258 :
33259 : (void)jenv;
33260 : (void)jcls;
33261 : (void)jarg1_;
33262 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33263 0 : result = (double) ((arg1)->ymax);
33264 0 : jresult = (jdouble)result;
33265 0 : return jresult;
33266 : }
33267 :
33268 :
33269 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1SuggestedWarpOutputRes(JNIEnv *jenv, jclass jcls, jlong jarg1) {
33270 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33271 :
33272 : (void)jenv;
33273 : (void)jcls;
33274 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33275 0 : delete_SuggestedWarpOutputRes(arg1);
33276 0 : }
33277 :
33278 :
33279 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutputRes_1GetGeotransform(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdoubleArray jarg2) {
33280 0 : SuggestedWarpOutputRes *arg1 = (SuggestedWarpOutputRes *) 0 ;
33281 : double *arg2 ;
33282 :
33283 : (void)jenv;
33284 : (void)jcls;
33285 : (void)jarg1_;
33286 0 : arg1 = *(SuggestedWarpOutputRes **)&jarg1;
33287 : {
33288 : /* %typemap(in) (double argout[ANY]) */
33289 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 6) {
33290 : char errorMsg[512];
33291 0 : sprintf(errorMsg, "array of size %d expected", 6);
33292 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
33293 0 : return ;
33294 : }
33295 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
33296 : }
33297 0 : SuggestedWarpOutputRes_GetGeotransform(arg1,arg2);
33298 : {
33299 : /* %typemap(argout) (double argout[ANY]) */
33300 : }
33301 : {
33302 : /* %typemap(freearg) (double argout[ANY]) */
33303 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
33304 : }
33305 : }
33306 :
33307 :
33308 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutput_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
33309 0 : jlong jresult = 0 ;
33310 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33311 0 : GDALTransformerInfoShadow *arg2 = (GDALTransformerInfoShadow *) 0 ;
33312 0 : SuggestedWarpOutputRes *result = 0 ;
33313 :
33314 : (void)jenv;
33315 : (void)jcls;
33316 : (void)jarg1_;
33317 : (void)jarg2_;
33318 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33319 0 : arg2 = *(GDALTransformerInfoShadow **)&jarg2;
33320 0 : result = (SuggestedWarpOutputRes *)SuggestedWarpOutput(arg1,arg2);
33321 0 : *(SuggestedWarpOutputRes **)&jresult = result;
33322 0 : return jresult;
33323 : }
33324 :
33325 :
33326 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_SuggestedWarpOutput_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2) {
33327 0 : jlong jresult = 0 ;
33328 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33329 0 : char **arg2 = (char **) 0 ;
33330 0 : SuggestedWarpOutputRes *result = 0 ;
33331 :
33332 : (void)jenv;
33333 : (void)jcls;
33334 : (void)jarg1_;
33335 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33336 : {
33337 : /* %typemap(in) char **options */
33338 0 : arg2 = NULL;
33339 0 : if(jarg2 != 0) {
33340 0 : const jclass vector = jenv->FindClass("java/util/Vector");
33341 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
33342 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
33343 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
33344 : "()Ljava/util/Enumeration;");
33345 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
33346 : "hasMoreElements", "()Z");
33347 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
33348 : "nextElement", "()Ljava/lang/Object;");
33349 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
33350 0 : hasMoreElements == NULL || getNextElement == NULL) {
33351 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
33352 0 : return 0;
33353 : }
33354 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
33355 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
33356 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
33357 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
33358 : {
33359 0 : CSLDestroy(arg2);
33360 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
33361 0 : return 0;
33362 : }
33363 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
33364 0 : arg2 = CSLAddString(arg2, valptr);
33365 0 : jenv->ReleaseStringUTFChars(value, valptr);
33366 : }
33367 : }
33368 : }
33369 0 : result = (SuggestedWarpOutputRes *)SuggestedWarpOutput(arg1,arg2);
33370 0 : *(SuggestedWarpOutputRes **)&jresult = result;
33371 : {
33372 : /* %typemap(freearg) char **options */
33373 0 : CSLDestroy( arg2 );
33374 : }
33375 0 : return jresult;
33376 : }
33377 :
33378 :
33379 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ApplyVerticalShiftGrid_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3, jdouble jarg4, jdouble jarg5, jobject jarg6) {
33380 0 : jlong jresult = 0 ;
33381 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33382 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
33383 : bool arg3 ;
33384 : double arg4 ;
33385 : double arg5 ;
33386 0 : char **arg6 = (char **) 0 ;
33387 0 : GDALDatasetShadow *result = 0 ;
33388 :
33389 : (void)jenv;
33390 : (void)jcls;
33391 : (void)jarg1_;
33392 : (void)jarg2_;
33393 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33394 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
33395 0 : arg3 = jarg3 ? true : false;
33396 0 : arg4 = (double)jarg4;
33397 0 : arg5 = (double)jarg5;
33398 : {
33399 : /* %typemap(in) char **options */
33400 0 : arg6 = NULL;
33401 0 : if(jarg6 != 0) {
33402 0 : const jclass vector = jenv->FindClass("java/util/Vector");
33403 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
33404 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
33405 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
33406 : "()Ljava/util/Enumeration;");
33407 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
33408 : "hasMoreElements", "()Z");
33409 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
33410 : "nextElement", "()Ljava/lang/Object;");
33411 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
33412 0 : hasMoreElements == NULL || getNextElement == NULL) {
33413 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
33414 0 : return 0;
33415 : }
33416 0 : for (jobject keys = jenv->CallObjectMethod(jarg6, elements);
33417 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
33418 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
33419 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
33420 : {
33421 0 : CSLDestroy(arg6);
33422 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
33423 0 : return 0;
33424 : }
33425 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
33426 0 : arg6 = CSLAddString(arg6, valptr);
33427 0 : jenv->ReleaseStringUTFChars(value, valptr);
33428 : }
33429 : }
33430 : }
33431 : {
33432 0 : if (!arg1) {
33433 : {
33434 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33435 : };
33436 : }
33437 : }
33438 : {
33439 0 : if (!arg2) {
33440 : {
33441 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33442 : };
33443 : }
33444 : }
33445 0 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2,arg3,arg4,arg5,arg6);
33446 0 : *(GDALDatasetShadow **)&jresult = result;
33447 : {
33448 : /* %typemap(freearg) char **options */
33449 0 : CSLDestroy( arg6 );
33450 : }
33451 0 : return jresult;
33452 : }
33453 :
33454 :
33455 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ApplyVerticalShiftGrid_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3, jdouble jarg4, jdouble jarg5) {
33456 0 : jlong jresult = 0 ;
33457 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33458 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
33459 : bool arg3 ;
33460 : double arg4 ;
33461 : double arg5 ;
33462 0 : GDALDatasetShadow *result = 0 ;
33463 :
33464 : (void)jenv;
33465 : (void)jcls;
33466 : (void)jarg1_;
33467 : (void)jarg2_;
33468 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33469 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
33470 0 : arg3 = jarg3 ? true : false;
33471 0 : arg4 = (double)jarg4;
33472 0 : arg5 = (double)jarg5;
33473 : {
33474 0 : if (!arg1) {
33475 : {
33476 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33477 : };
33478 : }
33479 : }
33480 : {
33481 0 : if (!arg2) {
33482 : {
33483 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33484 : };
33485 : }
33486 : }
33487 0 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2,arg3,arg4,arg5);
33488 0 : *(GDALDatasetShadow **)&jresult = result;
33489 0 : return jresult;
33490 : }
33491 :
33492 :
33493 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ApplyVerticalShiftGrid_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3, jdouble jarg4) {
33494 0 : jlong jresult = 0 ;
33495 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33496 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
33497 : bool arg3 ;
33498 : double arg4 ;
33499 0 : GDALDatasetShadow *result = 0 ;
33500 :
33501 : (void)jenv;
33502 : (void)jcls;
33503 : (void)jarg1_;
33504 : (void)jarg2_;
33505 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33506 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
33507 0 : arg3 = jarg3 ? true : false;
33508 0 : arg4 = (double)jarg4;
33509 : {
33510 0 : if (!arg1) {
33511 : {
33512 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33513 : };
33514 : }
33515 : }
33516 : {
33517 0 : if (!arg2) {
33518 : {
33519 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33520 : };
33521 : }
33522 : }
33523 0 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2,arg3,arg4);
33524 0 : *(GDALDatasetShadow **)&jresult = result;
33525 0 : return jresult;
33526 : }
33527 :
33528 :
33529 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ApplyVerticalShiftGrid_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jboolean jarg3) {
33530 0 : jlong jresult = 0 ;
33531 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33532 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
33533 : bool arg3 ;
33534 0 : GDALDatasetShadow *result = 0 ;
33535 :
33536 : (void)jenv;
33537 : (void)jcls;
33538 : (void)jarg1_;
33539 : (void)jarg2_;
33540 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33541 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
33542 0 : arg3 = jarg3 ? true : false;
33543 : {
33544 0 : if (!arg1) {
33545 : {
33546 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33547 : };
33548 : }
33549 : }
33550 : {
33551 0 : if (!arg2) {
33552 : {
33553 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33554 : };
33555 : }
33556 : }
33557 0 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2,arg3);
33558 0 : *(GDALDatasetShadow **)&jresult = result;
33559 0 : return jresult;
33560 : }
33561 :
33562 :
33563 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ApplyVerticalShiftGrid_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
33564 0 : jlong jresult = 0 ;
33565 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
33566 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
33567 0 : GDALDatasetShadow *result = 0 ;
33568 :
33569 : (void)jenv;
33570 : (void)jcls;
33571 : (void)jarg1_;
33572 : (void)jarg2_;
33573 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
33574 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
33575 : {
33576 0 : if (!arg1) {
33577 : {
33578 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33579 : };
33580 : }
33581 : }
33582 : {
33583 0 : if (!arg2) {
33584 : {
33585 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
33586 : };
33587 : }
33588 : }
33589 0 : result = (GDALDatasetShadow *)ApplyVerticalShiftGrid(arg1,arg2);
33590 0 : *(GDALDatasetShadow **)&jresult = result;
33591 0 : return jresult;
33592 : }
33593 :
33594 :
33595 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_ApplyGeoTransform(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5) {
33596 : double *arg1 ;
33597 : double arg2 ;
33598 : double arg3 ;
33599 0 : double *arg4 = (double *) 0 ;
33600 0 : double *arg5 = (double *) 0 ;
33601 : double temp4 ;
33602 : double temp5 ;
33603 :
33604 : (void)jenv;
33605 : (void)jcls;
33606 : {
33607 : /* %typemap(in) (double argin[ANY]) */
33608 0 : if(jarg1 == NULL || jenv->GetArrayLength(jarg1) != 6) {
33609 : char errorMsg[512];
33610 0 : sprintf(errorMsg, "array of size %d expected", 6);
33611 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
33612 0 : return ;
33613 : }
33614 0 : arg1 = (double *)jenv->GetDoubleArrayElements(jarg1, NULL);
33615 : }
33616 0 : arg2 = (double)jarg2;
33617 0 : arg3 = (double)jarg3;
33618 : {
33619 0 : if (!jarg4) {
33620 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
33621 0 : return ;
33622 : }
33623 0 : if (jenv->GetArrayLength(jarg4) == 0) {
33624 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
33625 0 : return ;
33626 : }
33627 0 : temp4 = (double)0;
33628 0 : arg4 = &temp4;
33629 : }
33630 : {
33631 0 : if (!jarg5) {
33632 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");
33633 0 : return ;
33634 : }
33635 0 : if (jenv->GetArrayLength(jarg5) == 0) {
33636 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");
33637 0 : return ;
33638 : }
33639 0 : temp5 = (double)0;
33640 0 : arg5 = &temp5;
33641 : }
33642 0 : GDALApplyGeoTransform(arg1,arg2,arg3,arg4,arg5);
33643 : {
33644 : /* %typemap(argout) (double argin[ANY]) */
33645 : }
33646 : {
33647 0 : jdouble jvalue = (jdouble)temp4;
33648 0 : jenv->SetDoubleArrayRegion(jarg4, 0, 1, &jvalue);
33649 : }
33650 : {
33651 0 : jdouble jvalue = (jdouble)temp5;
33652 0 : jenv->SetDoubleArrayRegion(jarg5, 0, 1, &jvalue);
33653 : }
33654 : {
33655 : /* %typemap(freearg) (double argin[ANY]) */
33656 0 : if(arg1) {
33657 0 : jenv->ReleaseDoubleArrayElements(jarg1, (jdouble *)arg1, JNI_ABORT);
33658 : }
33659 : }
33660 :
33661 :
33662 : }
33663 :
33664 :
33665 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_InvGeoTransform(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2) {
33666 0 : jint jresult = 0 ;
33667 : double *arg1 ;
33668 : double *arg2 ;
33669 : int result;
33670 :
33671 : (void)jenv;
33672 : (void)jcls;
33673 : {
33674 : /* %typemap(in) (double argin[ANY]) */
33675 0 : if(jarg1 == NULL || jenv->GetArrayLength(jarg1) != 6) {
33676 : char errorMsg[512];
33677 0 : sprintf(errorMsg, "array of size %d expected", 6);
33678 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
33679 0 : return 0;
33680 : }
33681 0 : arg1 = (double *)jenv->GetDoubleArrayElements(jarg1, NULL);
33682 : }
33683 : {
33684 : /* %typemap(in) (double argout[ANY]) */
33685 0 : if(jarg2 == NULL || jenv->GetArrayLength(jarg2) != 6) {
33686 : char errorMsg[512];
33687 0 : sprintf(errorMsg, "array of size %d expected", 6);
33688 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, errorMsg);
33689 0 : return 0;
33690 : }
33691 0 : arg2 = (double *)jenv->GetDoubleArrayElements(jarg2, NULL);
33692 : }
33693 0 : result = (int)GDALInvGeoTransform(arg1,arg2);
33694 0 : jresult = (jint)result;
33695 : {
33696 : /* %typemap(argout) (double argin[ANY]) */
33697 : }
33698 : {
33699 : /* %typemap(argout) (double argout[ANY]) */
33700 : }
33701 : {
33702 : /* %typemap(freearg) (double argin[ANY]) */
33703 0 : if(arg1) {
33704 0 : jenv->ReleaseDoubleArrayElements(jarg1, (jdouble *)arg1, JNI_ABORT);
33705 : }
33706 : }
33707 : {
33708 : /* %typemap(freearg) (double argout[ANY]) */
33709 0 : jenv->ReleaseDoubleArrayElements(jarg2, (jdouble *)arg2, 0);
33710 : }
33711 0 : return jresult;
33712 : }
33713 :
33714 :
33715 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_VersionInfo_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1) {
33716 0 : jstring jresult = 0 ;
33717 0 : char *arg1 = (char *) 0 ;
33718 0 : char *result = 0 ;
33719 :
33720 : (void)jenv;
33721 : (void)jcls;
33722 : {
33723 : /* %typemap(in) (const char* stringWithDefaultValue) */
33724 0 : if (jarg1)
33725 : {
33726 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
33727 : }
33728 : }
33729 0 : result = (char *)wrapper_GDALVersionInfo((char const *)arg1);
33730 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33731 : {
33732 : /* %typemap(freearg) (const char* stringWithDefaultValue) */
33733 0 : if (jarg1)
33734 : {
33735 0 : jenv->ReleaseStringUTFChars(jarg1, (char*)arg1);
33736 : }
33737 : }
33738 0 : return jresult;
33739 : }
33740 :
33741 :
33742 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_VersionInfo_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
33743 0 : jstring jresult = 0 ;
33744 0 : char *result = 0 ;
33745 :
33746 : (void)jenv;
33747 : (void)jcls;
33748 0 : result = (char *)wrapper_GDALVersionInfo();
33749 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33750 0 : return jresult;
33751 : }
33752 :
33753 :
33754 8 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_AllRegister(JNIEnv *jenv, jclass jcls) {
33755 : (void)jenv;
33756 : (void)jcls;
33757 8 : GDALAllRegister();
33758 8 : }
33759 :
33760 :
33761 1 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_GDALDestroyDriverManager(JNIEnv *jenv, jclass jcls) {
33762 : (void)jenv;
33763 : (void)jcls;
33764 1 : GDALDestroyDriverManager();
33765 1 : }
33766 :
33767 :
33768 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetCacheMax(JNIEnv *jenv, jclass jcls) {
33769 0 : jint jresult = 0 ;
33770 : int result;
33771 :
33772 : (void)jenv;
33773 : (void)jcls;
33774 0 : result = (int)wrapper_GDALGetCacheMax();
33775 0 : jresult = (jint)result;
33776 0 : return jresult;
33777 : }
33778 :
33779 :
33780 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetCacheUsed(JNIEnv *jenv, jclass jcls) {
33781 0 : jint jresult = 0 ;
33782 : int result;
33783 :
33784 : (void)jenv;
33785 : (void)jcls;
33786 0 : result = (int)wrapper_GDALGetCacheUsed();
33787 0 : jresult = (jint)result;
33788 0 : return jresult;
33789 : }
33790 :
33791 :
33792 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_SetCacheMax(JNIEnv *jenv, jclass jcls, jint jarg1) {
33793 : int arg1 ;
33794 :
33795 : (void)jenv;
33796 : (void)jcls;
33797 0 : arg1 = (int)jarg1;
33798 0 : wrapper_GDALSetCacheMax(arg1);
33799 0 : }
33800 :
33801 :
33802 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetDataTypeSize(JNIEnv *jenv, jclass jcls, jint jarg1) {
33803 0 : jint jresult = 0 ;
33804 : GDALDataType arg1 ;
33805 : int result;
33806 :
33807 : (void)jenv;
33808 : (void)jcls;
33809 0 : arg1 = (GDALDataType)jarg1;
33810 0 : result = (int)GDALGetDataTypeSize(arg1);
33811 0 : jresult = (jint)result;
33812 0 : return jresult;
33813 : }
33814 :
33815 :
33816 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_DataTypeIsComplex(JNIEnv *jenv, jclass jcls, jint jarg1) {
33817 0 : jint jresult = 0 ;
33818 : GDALDataType arg1 ;
33819 : int result;
33820 :
33821 : (void)jenv;
33822 : (void)jcls;
33823 0 : arg1 = (GDALDataType)jarg1;
33824 0 : result = (int)GDALDataTypeIsComplex(arg1);
33825 0 : jresult = (jint)result;
33826 0 : return jresult;
33827 : }
33828 :
33829 :
33830 1 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetDataTypeName(JNIEnv *jenv, jclass jcls, jint jarg1) {
33831 1 : jstring jresult = 0 ;
33832 : GDALDataType arg1 ;
33833 1 : char *result = 0 ;
33834 :
33835 : (void)jenv;
33836 : (void)jcls;
33837 1 : arg1 = (GDALDataType)jarg1;
33838 1 : result = (char *)GDALGetDataTypeName(arg1);
33839 1 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33840 1 : return jresult;
33841 : }
33842 :
33843 :
33844 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetDataTypeByName(JNIEnv *jenv, jclass jcls, jstring jarg1) {
33845 0 : jint jresult = 0 ;
33846 0 : char *arg1 = (char *) 0 ;
33847 : GDALDataType result;
33848 :
33849 : (void)jenv;
33850 : (void)jcls;
33851 0 : arg1 = 0;
33852 0 : if (jarg1) {
33853 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
33854 0 : if (!arg1) return 0;
33855 : }
33856 0 : result = (GDALDataType)GDALGetDataTypeByName((char const *)arg1);
33857 0 : jresult = (jint)result;
33858 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
33859 0 : return jresult;
33860 : }
33861 :
33862 :
33863 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_DataTypeUnion(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
33864 0 : jint jresult = 0 ;
33865 : GDALDataType arg1 ;
33866 : GDALDataType arg2 ;
33867 : GDALDataType result;
33868 :
33869 : (void)jenv;
33870 : (void)jcls;
33871 0 : arg1 = (GDALDataType)jarg1;
33872 0 : arg2 = (GDALDataType)jarg2;
33873 0 : result = (GDALDataType)GDALDataTypeUnion(arg1,arg2);
33874 0 : jresult = (jint)result;
33875 0 : return jresult;
33876 : }
33877 :
33878 :
33879 4 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetColorInterpretationName(JNIEnv *jenv, jclass jcls, jint jarg1) {
33880 4 : jstring jresult = 0 ;
33881 : GDALColorInterp arg1 ;
33882 4 : char *result = 0 ;
33883 :
33884 : (void)jenv;
33885 : (void)jcls;
33886 4 : arg1 = (GDALColorInterp)jarg1;
33887 4 : result = (char *)GDALGetColorInterpretationName(arg1);
33888 4 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33889 4 : return jresult;
33890 : }
33891 :
33892 :
33893 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetPaletteInterpretationName(JNIEnv *jenv, jclass jcls, jint jarg1) {
33894 0 : jstring jresult = 0 ;
33895 : GDALPaletteInterp arg1 ;
33896 0 : char *result = 0 ;
33897 :
33898 : (void)jenv;
33899 : (void)jcls;
33900 0 : arg1 = (GDALPaletteInterp)jarg1;
33901 0 : result = (char *)GDALGetPaletteInterpretationName(arg1);
33902 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33903 0 : return jresult;
33904 : }
33905 :
33906 :
33907 10 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_DecToDMS_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jdouble jarg1, jstring jarg2, jint jarg3) {
33908 10 : jstring jresult = 0 ;
33909 : double arg1 ;
33910 10 : char *arg2 = (char *) 0 ;
33911 : int arg3 ;
33912 10 : char *result = 0 ;
33913 :
33914 : (void)jenv;
33915 : (void)jcls;
33916 10 : arg1 = (double)jarg1;
33917 10 : arg2 = 0;
33918 10 : if (jarg2) {
33919 10 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
33920 10 : if (!arg2) return 0;
33921 : }
33922 10 : arg3 = (int)jarg3;
33923 10 : result = (char *)wrapper_GDALDecToDMS(arg1,(char const *)arg2,arg3);
33924 10 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33925 10 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
33926 10 : return jresult;
33927 : }
33928 :
33929 :
33930 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_DecToDMS_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jdouble jarg1, jstring jarg2) {
33931 0 : jstring jresult = 0 ;
33932 : double arg1 ;
33933 0 : char *arg2 = (char *) 0 ;
33934 0 : char *result = 0 ;
33935 :
33936 : (void)jenv;
33937 : (void)jcls;
33938 0 : arg1 = (double)jarg1;
33939 0 : arg2 = 0;
33940 0 : if (jarg2) {
33941 0 : arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
33942 0 : if (!arg2) return 0;
33943 : }
33944 0 : result = (char *)wrapper_GDALDecToDMS(arg1,(char const *)arg2);
33945 0 : if (result) jresult = jenv->NewStringUTF((const char *)result);
33946 0 : if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
33947 0 : return jresult;
33948 : }
33949 :
33950 :
33951 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_PackedDMSToDec(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
33952 0 : jdouble jresult = 0 ;
33953 : double arg1 ;
33954 : double result;
33955 :
33956 : (void)jenv;
33957 : (void)jcls;
33958 0 : arg1 = (double)jarg1;
33959 0 : result = (double)GDALPackedDMSToDec(arg1);
33960 0 : jresult = (jdouble)result;
33961 0 : return jresult;
33962 : }
33963 :
33964 :
33965 0 : SWIGEXPORT jdouble JNICALL Java_org_gdal_gdal_gdalJNI_DecToPackedDMS(JNIEnv *jenv, jclass jcls, jdouble jarg1) {
33966 0 : jdouble jresult = 0 ;
33967 : double arg1 ;
33968 : double result;
33969 :
33970 : (void)jenv;
33971 : (void)jcls;
33972 0 : arg1 = (double)jarg1;
33973 0 : result = (double)GDALDecToPackedDMS(arg1);
33974 0 : jresult = (jdouble)result;
33975 0 : return jresult;
33976 : }
33977 :
33978 :
33979 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_ParseXMLString(JNIEnv *jenv, jclass jcls, jstring jarg1) {
33980 0 : jlong jresult = 0 ;
33981 0 : char *arg1 = (char *) 0 ;
33982 0 : CPLXMLNode *result = 0 ;
33983 :
33984 : (void)jenv;
33985 : (void)jcls;
33986 0 : arg1 = 0;
33987 0 : if (jarg1) {
33988 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
33989 0 : if (!arg1) return 0;
33990 : }
33991 0 : result = (CPLXMLNode *)CPLParseXMLString(arg1);
33992 0 : *(CPLXMLNode **)&jresult = result;
33993 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
33994 0 : return jresult;
33995 : }
33996 :
33997 :
33998 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_SerializeXMLTree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
33999 0 : jstring jresult = 0 ;
34000 0 : CPLXMLNode *arg1 = (CPLXMLNode *) 0 ;
34001 0 : retStringAndCPLFree *result = 0 ;
34002 :
34003 : (void)jenv;
34004 : (void)jcls;
34005 : (void)jarg1_;
34006 0 : arg1 = *(CPLXMLNode **)&jarg1;
34007 0 : result = (retStringAndCPLFree *)CPLSerializeXMLTree(arg1);
34008 : {
34009 : /* %typemap(out) (retStringAndCPLFree*) */
34010 0 : if(result)
34011 : {
34012 0 : jresult = jenv->NewStringUTF((const char *)result);
34013 0 : CPLFree(result);
34014 : }
34015 : }
34016 0 : return jresult;
34017 : }
34018 :
34019 :
34020 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetJPEG2000StructureAsString_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2) {
34021 0 : jstring jresult = 0 ;
34022 0 : char *arg1 = (char *) 0 ;
34023 0 : char **arg2 = (char **) 0 ;
34024 0 : retStringAndCPLFree *result = 0 ;
34025 :
34026 : (void)jenv;
34027 : (void)jcls;
34028 0 : arg1 = 0;
34029 0 : if (jarg1) {
34030 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34031 0 : if (!arg1) return 0;
34032 : }
34033 : {
34034 : /* %typemap(in) char **options */
34035 0 : arg2 = NULL;
34036 0 : if(jarg2 != 0) {
34037 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34038 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34039 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34040 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34041 : "()Ljava/util/Enumeration;");
34042 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34043 : "hasMoreElements", "()Z");
34044 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34045 : "nextElement", "()Ljava/lang/Object;");
34046 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34047 0 : hasMoreElements == NULL || getNextElement == NULL) {
34048 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34049 0 : return 0;
34050 : }
34051 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
34052 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34053 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34054 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34055 : {
34056 0 : CSLDestroy(arg2);
34057 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34058 0 : return 0;
34059 : }
34060 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34061 0 : arg2 = CSLAddString(arg2, valptr);
34062 0 : jenv->ReleaseStringUTFChars(value, valptr);
34063 : }
34064 : }
34065 : }
34066 : {
34067 0 : if (!arg1) {
34068 : {
34069 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34070 : };
34071 : }
34072 : }
34073 0 : result = (retStringAndCPLFree *)GetJPEG2000StructureAsString((char const *)arg1,arg2);
34074 : {
34075 : /* %typemap(out) (retStringAndCPLFree*) */
34076 0 : if(result)
34077 : {
34078 0 : jresult = jenv->NewStringUTF((const char *)result);
34079 0 : CPLFree(result);
34080 : }
34081 : }
34082 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34083 : {
34084 : /* %typemap(freearg) char **options */
34085 0 : CSLDestroy( arg2 );
34086 : }
34087 0 : return jresult;
34088 : }
34089 :
34090 :
34091 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GetJPEG2000StructureAsString_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34092 0 : jstring jresult = 0 ;
34093 0 : char *arg1 = (char *) 0 ;
34094 0 : retStringAndCPLFree *result = 0 ;
34095 :
34096 : (void)jenv;
34097 : (void)jcls;
34098 0 : arg1 = 0;
34099 0 : if (jarg1) {
34100 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34101 0 : if (!arg1) return 0;
34102 : }
34103 : {
34104 0 : if (!arg1) {
34105 : {
34106 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34107 : };
34108 : }
34109 : }
34110 0 : result = (retStringAndCPLFree *)GetJPEG2000StructureAsString((char const *)arg1);
34111 : {
34112 : /* %typemap(out) (retStringAndCPLFree*) */
34113 0 : if(result)
34114 : {
34115 0 : jresult = jenv->NewStringUTF((const char *)result);
34116 0 : CPLFree(result);
34117 : }
34118 : }
34119 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34120 0 : return jresult;
34121 : }
34122 :
34123 :
34124 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_HasTriangulation(JNIEnv *jenv, jclass jcls) {
34125 0 : jint jresult = 0 ;
34126 : int result;
34127 :
34128 : (void)jenv;
34129 : (void)jcls;
34130 0 : result = (int)GDALHasTriangulation();
34131 0 : jresult = (jint)result;
34132 0 : return jresult;
34133 : }
34134 :
34135 :
34136 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_GetDriverCount(JNIEnv *jenv, jclass jcls) {
34137 0 : jint jresult = 0 ;
34138 : int result;
34139 :
34140 : (void)jenv;
34141 : (void)jcls;
34142 0 : result = (int)GetDriverCount();
34143 0 : jresult = (jint)result;
34144 0 : return jresult;
34145 : }
34146 :
34147 :
34148 8 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_GetDriverByName(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34149 8 : jlong jresult = 0 ;
34150 8 : char *arg1 = (char *) 0 ;
34151 8 : GDALDriverShadow *result = 0 ;
34152 :
34153 : (void)jenv;
34154 : (void)jcls;
34155 8 : arg1 = 0;
34156 8 : if (jarg1) {
34157 8 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34158 8 : if (!arg1) return 0;
34159 : }
34160 : {
34161 8 : if (!arg1) {
34162 : {
34163 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34164 : };
34165 : }
34166 : }
34167 8 : result = (GDALDriverShadow *)GetDriverByName((char const *)arg1);
34168 8 : *(GDALDriverShadow **)&jresult = result;
34169 8 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34170 8 : return jresult;
34171 : }
34172 :
34173 :
34174 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_GetDriver(JNIEnv *jenv, jclass jcls, jint jarg1) {
34175 0 : jlong jresult = 0 ;
34176 : int arg1 ;
34177 0 : GDALDriverShadow *result = 0 ;
34178 :
34179 : (void)jenv;
34180 : (void)jcls;
34181 0 : arg1 = (int)jarg1;
34182 0 : result = (GDALDriverShadow *)GetDriver(arg1);
34183 0 : *(GDALDriverShadow **)&jresult = result;
34184 0 : return jresult;
34185 : }
34186 :
34187 :
34188 3 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Open_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
34189 3 : jlong jresult = 0 ;
34190 3 : char *arg1 = (char *) 0 ;
34191 : GDALAccess arg2 ;
34192 3 : GDALDatasetShadow *result = 0 ;
34193 :
34194 : (void)jenv;
34195 : (void)jcls;
34196 3 : arg1 = 0;
34197 3 : if (jarg1) {
34198 3 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34199 3 : if (!arg1) return 0;
34200 : }
34201 3 : arg2 = (GDALAccess)jarg2;
34202 : {
34203 3 : if (!arg1) {
34204 : {
34205 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34206 : };
34207 : }
34208 : }
34209 3 : result = (GDALDatasetShadow *)Open((char const *)arg1,arg2);
34210 3 : *(GDALDatasetShadow **)&jresult = result;
34211 3 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34212 3 : return jresult;
34213 : }
34214 :
34215 :
34216 2 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Open_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34217 2 : jlong jresult = 0 ;
34218 2 : char *arg1 = (char *) 0 ;
34219 2 : GDALDatasetShadow *result = 0 ;
34220 :
34221 : (void)jenv;
34222 : (void)jcls;
34223 2 : arg1 = 0;
34224 2 : if (jarg1) {
34225 2 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34226 2 : if (!arg1) return 0;
34227 : }
34228 : {
34229 2 : if (!arg1) {
34230 : {
34231 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34232 : };
34233 : }
34234 : }
34235 2 : result = (GDALDatasetShadow *)Open((char const *)arg1);
34236 2 : *(GDALDatasetShadow **)&jresult = result;
34237 2 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34238 2 : return jresult;
34239 : }
34240 :
34241 :
34242 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenEx_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg3, jobject jarg4, jobject jarg5) {
34243 0 : jlong jresult = 0 ;
34244 0 : char *arg1 = (char *) 0 ;
34245 : unsigned int arg2 ;
34246 0 : char **arg3 = (char **) 0 ;
34247 0 : char **arg4 = (char **) 0 ;
34248 0 : char **arg5 = (char **) 0 ;
34249 0 : GDALDatasetShadow *result = 0 ;
34250 :
34251 : (void)jenv;
34252 : (void)jcls;
34253 0 : arg1 = 0;
34254 0 : if (jarg1) {
34255 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34256 0 : if (!arg1) return 0;
34257 : }
34258 0 : arg2 = (unsigned int)jarg2;
34259 : {
34260 : /* %typemap(in) char **options */
34261 0 : arg3 = NULL;
34262 0 : if(jarg3 != 0) {
34263 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34264 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34265 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34266 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34267 : "()Ljava/util/Enumeration;");
34268 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34269 : "hasMoreElements", "()Z");
34270 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34271 : "nextElement", "()Ljava/lang/Object;");
34272 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34273 0 : hasMoreElements == NULL || getNextElement == NULL) {
34274 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34275 0 : return 0;
34276 : }
34277 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
34278 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34279 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34280 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34281 : {
34282 0 : CSLDestroy(arg3);
34283 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34284 0 : return 0;
34285 : }
34286 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34287 0 : arg3 = CSLAddString(arg3, valptr);
34288 0 : jenv->ReleaseStringUTFChars(value, valptr);
34289 : }
34290 : }
34291 : }
34292 : {
34293 : /* %typemap(in) char **options */
34294 0 : arg4 = NULL;
34295 0 : if(jarg4 != 0) {
34296 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34297 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34298 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34299 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34300 : "()Ljava/util/Enumeration;");
34301 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34302 : "hasMoreElements", "()Z");
34303 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34304 : "nextElement", "()Ljava/lang/Object;");
34305 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34306 0 : hasMoreElements == NULL || getNextElement == NULL) {
34307 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34308 0 : return 0;
34309 : }
34310 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
34311 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34312 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34313 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34314 : {
34315 0 : CSLDestroy(arg4);
34316 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34317 0 : return 0;
34318 : }
34319 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34320 0 : arg4 = CSLAddString(arg4, valptr);
34321 0 : jenv->ReleaseStringUTFChars(value, valptr);
34322 : }
34323 : }
34324 : }
34325 : {
34326 : /* %typemap(in) char **options */
34327 0 : arg5 = NULL;
34328 0 : if(jarg5 != 0) {
34329 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34330 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34331 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34332 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34333 : "()Ljava/util/Enumeration;");
34334 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34335 : "hasMoreElements", "()Z");
34336 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34337 : "nextElement", "()Ljava/lang/Object;");
34338 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34339 0 : hasMoreElements == NULL || getNextElement == NULL) {
34340 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34341 0 : return 0;
34342 : }
34343 0 : for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
34344 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34345 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34346 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34347 : {
34348 0 : CSLDestroy(arg5);
34349 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34350 0 : return 0;
34351 : }
34352 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34353 0 : arg5 = CSLAddString(arg5, valptr);
34354 0 : jenv->ReleaseStringUTFChars(value, valptr);
34355 : }
34356 : }
34357 : }
34358 : {
34359 0 : if (!arg1) {
34360 : {
34361 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34362 : };
34363 : }
34364 : }
34365 0 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1,arg2,arg3,arg4,arg5);
34366 0 : *(GDALDatasetShadow **)&jresult = result;
34367 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34368 : {
34369 : /* %typemap(freearg) char **options */
34370 0 : CSLDestroy( arg3 );
34371 : }
34372 : {
34373 : /* %typemap(freearg) char **options */
34374 0 : CSLDestroy( arg4 );
34375 : }
34376 : {
34377 : /* %typemap(freearg) char **options */
34378 0 : CSLDestroy( arg5 );
34379 : }
34380 0 : return jresult;
34381 : }
34382 :
34383 :
34384 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenEx_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg3, jobject jarg4) {
34385 0 : jlong jresult = 0 ;
34386 0 : char *arg1 = (char *) 0 ;
34387 : unsigned int arg2 ;
34388 0 : char **arg3 = (char **) 0 ;
34389 0 : char **arg4 = (char **) 0 ;
34390 0 : GDALDatasetShadow *result = 0 ;
34391 :
34392 : (void)jenv;
34393 : (void)jcls;
34394 0 : arg1 = 0;
34395 0 : if (jarg1) {
34396 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34397 0 : if (!arg1) return 0;
34398 : }
34399 0 : arg2 = (unsigned int)jarg2;
34400 : {
34401 : /* %typemap(in) char **options */
34402 0 : arg3 = NULL;
34403 0 : if(jarg3 != 0) {
34404 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34405 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34406 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34407 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34408 : "()Ljava/util/Enumeration;");
34409 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34410 : "hasMoreElements", "()Z");
34411 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34412 : "nextElement", "()Ljava/lang/Object;");
34413 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34414 0 : hasMoreElements == NULL || getNextElement == NULL) {
34415 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34416 0 : return 0;
34417 : }
34418 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
34419 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34420 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34421 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34422 : {
34423 0 : CSLDestroy(arg3);
34424 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34425 0 : return 0;
34426 : }
34427 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34428 0 : arg3 = CSLAddString(arg3, valptr);
34429 0 : jenv->ReleaseStringUTFChars(value, valptr);
34430 : }
34431 : }
34432 : }
34433 : {
34434 : /* %typemap(in) char **options */
34435 0 : arg4 = NULL;
34436 0 : if(jarg4 != 0) {
34437 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34438 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34439 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34440 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34441 : "()Ljava/util/Enumeration;");
34442 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34443 : "hasMoreElements", "()Z");
34444 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34445 : "nextElement", "()Ljava/lang/Object;");
34446 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34447 0 : hasMoreElements == NULL || getNextElement == NULL) {
34448 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34449 0 : return 0;
34450 : }
34451 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
34452 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34453 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34454 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34455 : {
34456 0 : CSLDestroy(arg4);
34457 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34458 0 : return 0;
34459 : }
34460 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34461 0 : arg4 = CSLAddString(arg4, valptr);
34462 0 : jenv->ReleaseStringUTFChars(value, valptr);
34463 : }
34464 : }
34465 : }
34466 : {
34467 0 : if (!arg1) {
34468 : {
34469 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34470 : };
34471 : }
34472 : }
34473 0 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1,arg2,arg3,arg4);
34474 0 : *(GDALDatasetShadow **)&jresult = result;
34475 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34476 : {
34477 : /* %typemap(freearg) char **options */
34478 0 : CSLDestroy( arg3 );
34479 : }
34480 : {
34481 : /* %typemap(freearg) char **options */
34482 0 : CSLDestroy( arg4 );
34483 : }
34484 0 : return jresult;
34485 : }
34486 :
34487 :
34488 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenEx_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg3) {
34489 0 : jlong jresult = 0 ;
34490 0 : char *arg1 = (char *) 0 ;
34491 : unsigned int arg2 ;
34492 0 : char **arg3 = (char **) 0 ;
34493 0 : GDALDatasetShadow *result = 0 ;
34494 :
34495 : (void)jenv;
34496 : (void)jcls;
34497 0 : arg1 = 0;
34498 0 : if (jarg1) {
34499 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34500 0 : if (!arg1) return 0;
34501 : }
34502 0 : arg2 = (unsigned int)jarg2;
34503 : {
34504 : /* %typemap(in) char **options */
34505 0 : arg3 = NULL;
34506 0 : if(jarg3 != 0) {
34507 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34508 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34509 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34510 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34511 : "()Ljava/util/Enumeration;");
34512 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34513 : "hasMoreElements", "()Z");
34514 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34515 : "nextElement", "()Ljava/lang/Object;");
34516 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34517 0 : hasMoreElements == NULL || getNextElement == NULL) {
34518 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34519 0 : return 0;
34520 : }
34521 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
34522 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34523 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34524 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34525 : {
34526 0 : CSLDestroy(arg3);
34527 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34528 0 : return 0;
34529 : }
34530 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34531 0 : arg3 = CSLAddString(arg3, valptr);
34532 0 : jenv->ReleaseStringUTFChars(value, valptr);
34533 : }
34534 : }
34535 : }
34536 : {
34537 0 : if (!arg1) {
34538 : {
34539 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34540 : };
34541 : }
34542 : }
34543 0 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1,arg2,arg3);
34544 0 : *(GDALDatasetShadow **)&jresult = result;
34545 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34546 : {
34547 : /* %typemap(freearg) char **options */
34548 0 : CSLDestroy( arg3 );
34549 : }
34550 0 : return jresult;
34551 : }
34552 :
34553 :
34554 4 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenEx_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2) {
34555 4 : jlong jresult = 0 ;
34556 4 : char *arg1 = (char *) 0 ;
34557 : unsigned int arg2 ;
34558 4 : GDALDatasetShadow *result = 0 ;
34559 :
34560 : (void)jenv;
34561 : (void)jcls;
34562 4 : arg1 = 0;
34563 4 : if (jarg1) {
34564 4 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34565 4 : if (!arg1) return 0;
34566 : }
34567 4 : arg2 = (unsigned int)jarg2;
34568 : {
34569 4 : if (!arg1) {
34570 : {
34571 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34572 : };
34573 : }
34574 : }
34575 4 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1,arg2);
34576 4 : *(GDALDatasetShadow **)&jresult = result;
34577 4 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34578 4 : return jresult;
34579 : }
34580 :
34581 :
34582 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenEx_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34583 0 : jlong jresult = 0 ;
34584 0 : char *arg1 = (char *) 0 ;
34585 0 : GDALDatasetShadow *result = 0 ;
34586 :
34587 : (void)jenv;
34588 : (void)jcls;
34589 0 : arg1 = 0;
34590 0 : if (jarg1) {
34591 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34592 0 : if (!arg1) return 0;
34593 : }
34594 : {
34595 0 : if (!arg1) {
34596 : {
34597 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34598 : };
34599 : }
34600 : }
34601 0 : result = (GDALDatasetShadow *)OpenEx((char const *)arg1);
34602 0 : *(GDALDatasetShadow **)&jresult = result;
34603 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34604 0 : return jresult;
34605 : }
34606 :
34607 :
34608 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenShared_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
34609 0 : jlong jresult = 0 ;
34610 0 : char *arg1 = (char *) 0 ;
34611 : GDALAccess arg2 ;
34612 0 : GDALDatasetShadow *result = 0 ;
34613 :
34614 : (void)jenv;
34615 : (void)jcls;
34616 0 : arg1 = 0;
34617 0 : if (jarg1) {
34618 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34619 0 : if (!arg1) return 0;
34620 : }
34621 0 : arg2 = (GDALAccess)jarg2;
34622 : {
34623 0 : if (!arg1) {
34624 : {
34625 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34626 : };
34627 : }
34628 : }
34629 0 : result = (GDALDatasetShadow *)OpenShared((char const *)arg1,arg2);
34630 0 : *(GDALDatasetShadow **)&jresult = result;
34631 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34632 0 : return jresult;
34633 : }
34634 :
34635 :
34636 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_OpenShared_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34637 0 : jlong jresult = 0 ;
34638 0 : char *arg1 = (char *) 0 ;
34639 0 : GDALDatasetShadow *result = 0 ;
34640 :
34641 : (void)jenv;
34642 : (void)jcls;
34643 0 : arg1 = 0;
34644 0 : if (jarg1) {
34645 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34646 0 : if (!arg1) return 0;
34647 : }
34648 : {
34649 0 : if (!arg1) {
34650 : {
34651 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34652 : };
34653 : }
34654 : }
34655 0 : result = (GDALDatasetShadow *)OpenShared((char const *)arg1);
34656 0 : *(GDALDatasetShadow **)&jresult = result;
34657 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34658 0 : return jresult;
34659 : }
34660 :
34661 :
34662 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriver_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2) {
34663 0 : jlong jresult = 0 ;
34664 0 : char *arg1 = (char *) 0 ;
34665 0 : char **arg2 = (char **) 0 ;
34666 0 : GDALDriverShadow *result = 0 ;
34667 :
34668 : (void)jenv;
34669 : (void)jcls;
34670 0 : arg1 = 0;
34671 0 : if (jarg1) {
34672 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34673 0 : if (!arg1) return 0;
34674 : }
34675 : {
34676 : /* %typemap(in) char **options */
34677 0 : arg2 = NULL;
34678 0 : if(jarg2 != 0) {
34679 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34680 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34681 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34682 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34683 : "()Ljava/util/Enumeration;");
34684 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34685 : "hasMoreElements", "()Z");
34686 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34687 : "nextElement", "()Ljava/lang/Object;");
34688 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34689 0 : hasMoreElements == NULL || getNextElement == NULL) {
34690 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34691 0 : return 0;
34692 : }
34693 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
34694 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34695 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34696 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34697 : {
34698 0 : CSLDestroy(arg2);
34699 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34700 0 : return 0;
34701 : }
34702 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34703 0 : arg2 = CSLAddString(arg2, valptr);
34704 0 : jenv->ReleaseStringUTFChars(value, valptr);
34705 : }
34706 : }
34707 : }
34708 : {
34709 0 : if (!arg1) {
34710 : {
34711 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34712 : };
34713 : }
34714 : }
34715 0 : result = (GDALDriverShadow *)IdentifyDriver((char const *)arg1,arg2);
34716 0 : *(GDALDriverShadow **)&jresult = result;
34717 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34718 : {
34719 : /* %typemap(freearg) char **options */
34720 0 : CSLDestroy( arg2 );
34721 : }
34722 0 : return jresult;
34723 : }
34724 :
34725 :
34726 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriver_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34727 0 : jlong jresult = 0 ;
34728 0 : char *arg1 = (char *) 0 ;
34729 0 : GDALDriverShadow *result = 0 ;
34730 :
34731 : (void)jenv;
34732 : (void)jcls;
34733 0 : arg1 = 0;
34734 0 : if (jarg1) {
34735 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34736 0 : if (!arg1) return 0;
34737 : }
34738 : {
34739 0 : if (!arg1) {
34740 : {
34741 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34742 : };
34743 : }
34744 : }
34745 0 : result = (GDALDriverShadow *)IdentifyDriver((char const *)arg1);
34746 0 : *(GDALDriverShadow **)&jresult = result;
34747 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34748 0 : return jresult;
34749 : }
34750 :
34751 :
34752 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriverEx_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg3, jobject jarg4) {
34753 0 : jlong jresult = 0 ;
34754 0 : char *arg1 = (char *) 0 ;
34755 : unsigned int arg2 ;
34756 0 : char **arg3 = (char **) 0 ;
34757 0 : char **arg4 = (char **) 0 ;
34758 0 : GDALDriverShadow *result = 0 ;
34759 :
34760 : (void)jenv;
34761 : (void)jcls;
34762 0 : arg1 = 0;
34763 0 : if (jarg1) {
34764 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34765 0 : if (!arg1) return 0;
34766 : }
34767 0 : arg2 = (unsigned int)jarg2;
34768 : {
34769 : /* %typemap(in) char **options */
34770 0 : arg3 = NULL;
34771 0 : if(jarg3 != 0) {
34772 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34773 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34774 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34775 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34776 : "()Ljava/util/Enumeration;");
34777 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34778 : "hasMoreElements", "()Z");
34779 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34780 : "nextElement", "()Ljava/lang/Object;");
34781 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34782 0 : hasMoreElements == NULL || getNextElement == NULL) {
34783 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34784 0 : return 0;
34785 : }
34786 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
34787 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34788 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34789 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34790 : {
34791 0 : CSLDestroy(arg3);
34792 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34793 0 : return 0;
34794 : }
34795 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34796 0 : arg3 = CSLAddString(arg3, valptr);
34797 0 : jenv->ReleaseStringUTFChars(value, valptr);
34798 : }
34799 : }
34800 : }
34801 : {
34802 : /* %typemap(in) char **options */
34803 0 : arg4 = NULL;
34804 0 : if(jarg4 != 0) {
34805 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34806 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34807 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34808 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34809 : "()Ljava/util/Enumeration;");
34810 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34811 : "hasMoreElements", "()Z");
34812 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34813 : "nextElement", "()Ljava/lang/Object;");
34814 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34815 0 : hasMoreElements == NULL || getNextElement == NULL) {
34816 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34817 0 : return 0;
34818 : }
34819 0 : for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
34820 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34821 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34822 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34823 : {
34824 0 : CSLDestroy(arg4);
34825 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34826 0 : return 0;
34827 : }
34828 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34829 0 : arg4 = CSLAddString(arg4, valptr);
34830 0 : jenv->ReleaseStringUTFChars(value, valptr);
34831 : }
34832 : }
34833 : }
34834 : {
34835 0 : if (!arg1) {
34836 : {
34837 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34838 : };
34839 : }
34840 : }
34841 0 : result = (GDALDriverShadow *)IdentifyDriverEx((char const *)arg1,arg2,arg3,arg4);
34842 0 : *(GDALDriverShadow **)&jresult = result;
34843 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34844 : {
34845 : /* %typemap(freearg) char **options */
34846 0 : CSLDestroy( arg3 );
34847 : }
34848 : {
34849 : /* %typemap(freearg) char **options */
34850 0 : CSLDestroy( arg4 );
34851 : }
34852 0 : return jresult;
34853 : }
34854 :
34855 :
34856 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriverEx_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg3) {
34857 0 : jlong jresult = 0 ;
34858 0 : char *arg1 = (char *) 0 ;
34859 : unsigned int arg2 ;
34860 0 : char **arg3 = (char **) 0 ;
34861 0 : GDALDriverShadow *result = 0 ;
34862 :
34863 : (void)jenv;
34864 : (void)jcls;
34865 0 : arg1 = 0;
34866 0 : if (jarg1) {
34867 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34868 0 : if (!arg1) return 0;
34869 : }
34870 0 : arg2 = (unsigned int)jarg2;
34871 : {
34872 : /* %typemap(in) char **options */
34873 0 : arg3 = NULL;
34874 0 : if(jarg3 != 0) {
34875 0 : const jclass vector = jenv->FindClass("java/util/Vector");
34876 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34877 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
34878 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34879 : "()Ljava/util/Enumeration;");
34880 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34881 : "hasMoreElements", "()Z");
34882 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34883 : "nextElement", "()Ljava/lang/Object;");
34884 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34885 0 : hasMoreElements == NULL || getNextElement == NULL) {
34886 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
34887 0 : return 0;
34888 : }
34889 0 : for (jobject keys = jenv->CallObjectMethod(jarg3, elements);
34890 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
34891 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
34892 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
34893 : {
34894 0 : CSLDestroy(arg3);
34895 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
34896 0 : return 0;
34897 : }
34898 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
34899 0 : arg3 = CSLAddString(arg3, valptr);
34900 0 : jenv->ReleaseStringUTFChars(value, valptr);
34901 : }
34902 : }
34903 : }
34904 : {
34905 0 : if (!arg1) {
34906 : {
34907 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34908 : };
34909 : }
34910 : }
34911 0 : result = (GDALDriverShadow *)IdentifyDriverEx((char const *)arg1,arg2,arg3);
34912 0 : *(GDALDriverShadow **)&jresult = result;
34913 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34914 : {
34915 : /* %typemap(freearg) char **options */
34916 0 : CSLDestroy( arg3 );
34917 : }
34918 0 : return jresult;
34919 : }
34920 :
34921 :
34922 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriverEx_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2) {
34923 0 : jlong jresult = 0 ;
34924 0 : char *arg1 = (char *) 0 ;
34925 : unsigned int arg2 ;
34926 0 : GDALDriverShadow *result = 0 ;
34927 :
34928 : (void)jenv;
34929 : (void)jcls;
34930 0 : arg1 = 0;
34931 0 : if (jarg1) {
34932 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34933 0 : if (!arg1) return 0;
34934 : }
34935 0 : arg2 = (unsigned int)jarg2;
34936 : {
34937 0 : if (!arg1) {
34938 : {
34939 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34940 : };
34941 : }
34942 : }
34943 0 : result = (GDALDriverShadow *)IdentifyDriverEx((char const *)arg1,arg2);
34944 0 : *(GDALDriverShadow **)&jresult = result;
34945 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34946 0 : return jresult;
34947 : }
34948 :
34949 :
34950 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_IdentifyDriverEx_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1) {
34951 0 : jlong jresult = 0 ;
34952 0 : char *arg1 = (char *) 0 ;
34953 0 : GDALDriverShadow *result = 0 ;
34954 :
34955 : (void)jenv;
34956 : (void)jcls;
34957 0 : arg1 = 0;
34958 0 : if (jarg1) {
34959 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
34960 0 : if (!arg1) return 0;
34961 : }
34962 : {
34963 0 : if (!arg1) {
34964 : {
34965 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
34966 : };
34967 : }
34968 : }
34969 0 : result = (GDALDriverShadow *)IdentifyDriverEx((char const *)arg1);
34970 0 : *(GDALDriverShadow **)&jresult = result;
34971 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
34972 0 : return jresult;
34973 : }
34974 :
34975 :
34976 2 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_GeneralCmdLineProcessor_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jobject jarg1, jint jarg2) {
34977 2 : jobject jresult = 0 ;
34978 2 : char **arg1 = (char **) 0 ;
34979 : int arg2 ;
34980 2 : char **result = 0 ;
34981 :
34982 : (void)jenv;
34983 : (void)jcls;
34984 : {
34985 : /* %typemap(in) char **options */
34986 2 : arg1 = NULL;
34987 2 : if(jarg1 != 0) {
34988 2 : const jclass vector = jenv->FindClass("java/util/Vector");
34989 2 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
34990 2 : const jclass stringClass = jenv->FindClass("java/lang/String");
34991 2 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
34992 : "()Ljava/util/Enumeration;");
34993 2 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
34994 : "hasMoreElements", "()Z");
34995 2 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
34996 : "nextElement", "()Ljava/lang/Object;");
34997 2 : if(vector == NULL || enumeration == NULL || elements == NULL ||
34998 2 : hasMoreElements == NULL || getNextElement == NULL) {
34999 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35000 0 : return 0;
35001 : }
35002 8 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35003 8 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35004 6 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35005 6 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35006 : {
35007 0 : CSLDestroy(arg1);
35008 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35009 0 : return 0;
35010 : }
35011 6 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35012 6 : arg1 = CSLAddString(arg1, valptr);
35013 6 : jenv->ReleaseStringUTFChars(value, valptr);
35014 : }
35015 : }
35016 : }
35017 2 : arg2 = (int)jarg2;
35018 2 : result = (char **)GeneralCmdLineProcessor(arg1,arg2);
35019 : {
35020 : /* %typemap(out) char **CSL */
35021 2 : char **stringarray = result;
35022 2 : const jclass vector = jenv->FindClass("java/util/Vector");
35023 2 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
35024 2 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
35025 :
35026 2 : jresult = jenv->NewObject(vector, constructor);
35027 2 : if ( stringarray != NULL ) {
35028 8 : while(*stringarray != NULL) {
35029 : /*printf("working on string %s\n", *stringarray);*/
35030 6 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
35031 6 : jenv->CallBooleanMethod(jresult, add, value);
35032 6 : jenv->DeleteLocalRef(value);
35033 6 : stringarray++;
35034 : }
35035 : }
35036 2 : CSLDestroy(result);
35037 : }
35038 : {
35039 : /* %typemap(freearg) char **options */
35040 2 : CSLDestroy( arg1 );
35041 : }
35042 2 : return jresult;
35043 : }
35044 :
35045 :
35046 0 : SWIGEXPORT jobject JNICALL Java_org_gdal_gdal_gdalJNI_GeneralCmdLineProcessor_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35047 0 : jobject jresult = 0 ;
35048 0 : char **arg1 = (char **) 0 ;
35049 0 : char **result = 0 ;
35050 :
35051 : (void)jenv;
35052 : (void)jcls;
35053 : {
35054 : /* %typemap(in) char **options */
35055 0 : arg1 = NULL;
35056 0 : if(jarg1 != 0) {
35057 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35058 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35059 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35060 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35061 : "()Ljava/util/Enumeration;");
35062 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35063 : "hasMoreElements", "()Z");
35064 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35065 : "nextElement", "()Ljava/lang/Object;");
35066 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35067 0 : hasMoreElements == NULL || getNextElement == NULL) {
35068 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35069 0 : return 0;
35070 : }
35071 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35072 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35073 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35074 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35075 : {
35076 0 : CSLDestroy(arg1);
35077 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35078 0 : return 0;
35079 : }
35080 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35081 0 : arg1 = CSLAddString(arg1, valptr);
35082 0 : jenv->ReleaseStringUTFChars(value, valptr);
35083 : }
35084 : }
35085 : }
35086 0 : result = (char **)GeneralCmdLineProcessor(arg1);
35087 : {
35088 : /* %typemap(out) char **CSL */
35089 0 : char **stringarray = result;
35090 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35091 0 : const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
35092 0 : const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
35093 :
35094 0 : jresult = jenv->NewObject(vector, constructor);
35095 0 : if ( stringarray != NULL ) {
35096 0 : while(*stringarray != NULL) {
35097 : /*printf("working on string %s\n", *stringarray);*/
35098 0 : jstring value = (jstring)jenv->NewStringUTF(*stringarray);
35099 0 : jenv->CallBooleanMethod(jresult, add, value);
35100 0 : jenv->DeleteLocalRef(value);
35101 0 : stringarray++;
35102 : }
35103 : }
35104 0 : CSLDestroy(result);
35105 : }
35106 : {
35107 : /* %typemap(freearg) char **options */
35108 0 : CSLDestroy( arg1 );
35109 : }
35110 0 : return jresult;
35111 : }
35112 :
35113 :
35114 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1InfoOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35115 0 : jlong jresult = 0 ;
35116 0 : char **arg1 = (char **) 0 ;
35117 0 : GDALInfoOptions *result = 0 ;
35118 :
35119 : (void)jenv;
35120 : (void)jcls;
35121 : {
35122 : /* %typemap(in) char **options */
35123 0 : arg1 = NULL;
35124 0 : if(jarg1 != 0) {
35125 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35126 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35127 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35128 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35129 : "()Ljava/util/Enumeration;");
35130 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35131 : "hasMoreElements", "()Z");
35132 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35133 : "nextElement", "()Ljava/lang/Object;");
35134 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35135 0 : hasMoreElements == NULL || getNextElement == NULL) {
35136 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35137 0 : return 0;
35138 : }
35139 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35140 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35141 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35142 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35143 : {
35144 0 : CSLDestroy(arg1);
35145 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35146 0 : return 0;
35147 : }
35148 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35149 0 : arg1 = CSLAddString(arg1, valptr);
35150 0 : jenv->ReleaseStringUTFChars(value, valptr);
35151 : }
35152 : }
35153 : }
35154 0 : result = (GDALInfoOptions *)new_GDALInfoOptions(arg1);
35155 0 : *(GDALInfoOptions **)&jresult = result;
35156 : {
35157 : /* %typemap(freearg) char **options */
35158 0 : CSLDestroy( arg1 );
35159 : }
35160 0 : return jresult;
35161 : }
35162 :
35163 :
35164 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1InfoOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35165 0 : GDALInfoOptions *arg1 = (GDALInfoOptions *) 0 ;
35166 :
35167 : (void)jenv;
35168 : (void)jcls;
35169 0 : arg1 = *(GDALInfoOptions **)&jarg1;
35170 0 : delete_GDALInfoOptions(arg1);
35171 0 : }
35172 :
35173 :
35174 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GDALInfo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
35175 0 : jstring jresult = 0 ;
35176 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35177 0 : GDALInfoOptions *arg2 = (GDALInfoOptions *) 0 ;
35178 0 : retStringAndCPLFree *result = 0 ;
35179 :
35180 : (void)jenv;
35181 : (void)jcls;
35182 : (void)jarg1_;
35183 : (void)jarg2_;
35184 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35185 0 : arg2 = *(GDALInfoOptions **)&jarg2;
35186 0 : result = (retStringAndCPLFree *)GDALInfo(arg1,arg2);
35187 : {
35188 : /* %typemap(out) (retStringAndCPLFree*) */
35189 0 : if(result)
35190 : {
35191 0 : jresult = jenv->NewStringUTF((const char *)result);
35192 0 : CPLFree(result);
35193 : }
35194 : }
35195 0 : return jresult;
35196 : }
35197 :
35198 :
35199 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1VectorInfoOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35200 0 : jlong jresult = 0 ;
35201 0 : char **arg1 = (char **) 0 ;
35202 0 : GDALVectorInfoOptions *result = 0 ;
35203 :
35204 : (void)jenv;
35205 : (void)jcls;
35206 : {
35207 : /* %typemap(in) char **options */
35208 0 : arg1 = NULL;
35209 0 : if(jarg1 != 0) {
35210 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35211 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35212 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35213 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35214 : "()Ljava/util/Enumeration;");
35215 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35216 : "hasMoreElements", "()Z");
35217 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35218 : "nextElement", "()Ljava/lang/Object;");
35219 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35220 0 : hasMoreElements == NULL || getNextElement == NULL) {
35221 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35222 0 : return 0;
35223 : }
35224 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35225 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35226 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35227 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35228 : {
35229 0 : CSLDestroy(arg1);
35230 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35231 0 : return 0;
35232 : }
35233 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35234 0 : arg1 = CSLAddString(arg1, valptr);
35235 0 : jenv->ReleaseStringUTFChars(value, valptr);
35236 : }
35237 : }
35238 : }
35239 0 : result = (GDALVectorInfoOptions *)new_GDALVectorInfoOptions(arg1);
35240 0 : *(GDALVectorInfoOptions **)&jresult = result;
35241 : {
35242 : /* %typemap(freearg) char **options */
35243 0 : CSLDestroy( arg1 );
35244 : }
35245 0 : return jresult;
35246 : }
35247 :
35248 :
35249 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1VectorInfoOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35250 0 : GDALVectorInfoOptions *arg1 = (GDALVectorInfoOptions *) 0 ;
35251 :
35252 : (void)jenv;
35253 : (void)jcls;
35254 0 : arg1 = *(GDALVectorInfoOptions **)&jarg1;
35255 0 : delete_GDALVectorInfoOptions(arg1);
35256 0 : }
35257 :
35258 :
35259 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GDALVectorInfo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
35260 0 : jstring jresult = 0 ;
35261 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35262 0 : GDALVectorInfoOptions *arg2 = (GDALVectorInfoOptions *) 0 ;
35263 0 : retStringAndCPLFree *result = 0 ;
35264 :
35265 : (void)jenv;
35266 : (void)jcls;
35267 : (void)jarg1_;
35268 : (void)jarg2_;
35269 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35270 0 : arg2 = *(GDALVectorInfoOptions **)&jarg2;
35271 0 : result = (retStringAndCPLFree *)GDALVectorInfo(arg1,arg2);
35272 : {
35273 : /* %typemap(out) (retStringAndCPLFree*) */
35274 0 : if(result)
35275 : {
35276 0 : jresult = jenv->NewStringUTF((const char *)result);
35277 0 : CPLFree(result);
35278 : }
35279 : }
35280 0 : return jresult;
35281 : }
35282 :
35283 :
35284 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1MultiDimInfoOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35285 0 : jlong jresult = 0 ;
35286 0 : char **arg1 = (char **) 0 ;
35287 0 : GDALMultiDimInfoOptions *result = 0 ;
35288 :
35289 : (void)jenv;
35290 : (void)jcls;
35291 : {
35292 : /* %typemap(in) char **options */
35293 0 : arg1 = NULL;
35294 0 : if(jarg1 != 0) {
35295 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35296 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35297 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35298 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35299 : "()Ljava/util/Enumeration;");
35300 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35301 : "hasMoreElements", "()Z");
35302 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35303 : "nextElement", "()Ljava/lang/Object;");
35304 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35305 0 : hasMoreElements == NULL || getNextElement == NULL) {
35306 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35307 0 : return 0;
35308 : }
35309 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35310 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35311 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35312 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35313 : {
35314 0 : CSLDestroy(arg1);
35315 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35316 0 : return 0;
35317 : }
35318 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35319 0 : arg1 = CSLAddString(arg1, valptr);
35320 0 : jenv->ReleaseStringUTFChars(value, valptr);
35321 : }
35322 : }
35323 : }
35324 0 : result = (GDALMultiDimInfoOptions *)new_GDALMultiDimInfoOptions(arg1);
35325 0 : *(GDALMultiDimInfoOptions **)&jresult = result;
35326 : {
35327 : /* %typemap(freearg) char **options */
35328 0 : CSLDestroy( arg1 );
35329 : }
35330 0 : return jresult;
35331 : }
35332 :
35333 :
35334 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1MultiDimInfoOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35335 0 : GDALMultiDimInfoOptions *arg1 = (GDALMultiDimInfoOptions *) 0 ;
35336 :
35337 : (void)jenv;
35338 : (void)jcls;
35339 0 : arg1 = *(GDALMultiDimInfoOptions **)&jarg1;
35340 0 : delete_GDALMultiDimInfoOptions(arg1);
35341 0 : }
35342 :
35343 :
35344 0 : SWIGEXPORT jstring JNICALL Java_org_gdal_gdal_gdalJNI_GDALMultiDimInfo(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
35345 0 : jstring jresult = 0 ;
35346 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35347 0 : GDALMultiDimInfoOptions *arg2 = (GDALMultiDimInfoOptions *) 0 ;
35348 0 : retStringAndCPLFree *result = 0 ;
35349 :
35350 : (void)jenv;
35351 : (void)jcls;
35352 : (void)jarg1_;
35353 : (void)jarg2_;
35354 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35355 0 : arg2 = *(GDALMultiDimInfoOptions **)&jarg2;
35356 0 : result = (retStringAndCPLFree *)GDALMultiDimInfo(arg1,arg2);
35357 : {
35358 : /* %typemap(out) (retStringAndCPLFree*) */
35359 0 : if(result)
35360 : {
35361 0 : jresult = jenv->NewStringUTF((const char *)result);
35362 0 : CPLFree(result);
35363 : }
35364 : }
35365 0 : return jresult;
35366 : }
35367 :
35368 :
35369 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1TranslateOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35370 0 : jlong jresult = 0 ;
35371 0 : char **arg1 = (char **) 0 ;
35372 0 : GDALTranslateOptions *result = 0 ;
35373 :
35374 : (void)jenv;
35375 : (void)jcls;
35376 : {
35377 : /* %typemap(in) char **options */
35378 0 : arg1 = NULL;
35379 0 : if(jarg1 != 0) {
35380 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35381 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35382 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35383 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35384 : "()Ljava/util/Enumeration;");
35385 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35386 : "hasMoreElements", "()Z");
35387 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35388 : "nextElement", "()Ljava/lang/Object;");
35389 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35390 0 : hasMoreElements == NULL || getNextElement == NULL) {
35391 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35392 0 : return 0;
35393 : }
35394 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35395 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35396 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35397 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35398 : {
35399 0 : CSLDestroy(arg1);
35400 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35401 0 : return 0;
35402 : }
35403 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35404 0 : arg1 = CSLAddString(arg1, valptr);
35405 0 : jenv->ReleaseStringUTFChars(value, valptr);
35406 : }
35407 : }
35408 : }
35409 0 : result = (GDALTranslateOptions *)new_GDALTranslateOptions(arg1);
35410 0 : *(GDALTranslateOptions **)&jresult = result;
35411 : {
35412 : /* %typemap(freearg) char **options */
35413 0 : CSLDestroy( arg1 );
35414 : }
35415 0 : return jresult;
35416 : }
35417 :
35418 :
35419 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1TranslateOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35420 0 : GDALTranslateOptions *arg1 = (GDALTranslateOptions *) 0 ;
35421 :
35422 : (void)jenv;
35423 : (void)jcls;
35424 0 : arg1 = *(GDALTranslateOptions **)&jarg1;
35425 0 : delete_GDALTranslateOptions(arg1);
35426 0 : }
35427 :
35428 :
35429 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Translate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
35430 0 : jlong jresult = 0 ;
35431 0 : char *arg1 = (char *) 0 ;
35432 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
35433 0 : GDALTranslateOptions *arg3 = (GDALTranslateOptions *) 0 ;
35434 : GDALProgressFunc arg4 ;
35435 0 : void *arg5 = (void *) 0 ;
35436 0 : GDALDatasetShadow *result = 0 ;
35437 :
35438 : (void)jenv;
35439 : (void)jcls;
35440 : JavaProgressData sProgressInfo;
35441 0 : sProgressInfo.jenv = jenv;
35442 0 : sProgressInfo.pJavaCallback = NULL;
35443 : (void)jarg2_;
35444 : (void)jarg3_;
35445 0 : arg1 = 0;
35446 0 : if (jarg1) {
35447 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
35448 0 : if (!arg1) return 0;
35449 : }
35450 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
35451 0 : arg3 = *(GDALTranslateOptions **)&jarg3;
35452 : {
35453 0 : if ( jarg4 != 0 ) {
35454 0 : sProgressInfo.pJavaCallback = jarg4;
35455 0 : arg4 = JavaProgressProxy;
35456 0 : arg5 = &sProgressInfo;
35457 : }
35458 : else
35459 : {
35460 0 : arg4 = NULL;
35461 0 : arg5 = NULL;
35462 : }
35463 : }
35464 : {
35465 0 : if (!arg1) {
35466 : {
35467 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35468 : };
35469 : }
35470 : }
35471 : {
35472 0 : if (!arg2) {
35473 : {
35474 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35475 : };
35476 : }
35477 : }
35478 0 : result = (GDALDatasetShadow *)wrapper_GDALTranslate((char const *)arg1,arg2,arg3,arg4,arg5);
35479 0 : *(GDALDatasetShadow **)&jresult = result;
35480 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
35481 0 : return jresult;
35482 : }
35483 :
35484 :
35485 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Translate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
35486 0 : jlong jresult = 0 ;
35487 0 : char *arg1 = (char *) 0 ;
35488 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
35489 0 : GDALTranslateOptions *arg3 = (GDALTranslateOptions *) 0 ;
35490 0 : GDALDatasetShadow *result = 0 ;
35491 :
35492 : (void)jenv;
35493 : (void)jcls;
35494 : (void)jarg2_;
35495 : (void)jarg3_;
35496 0 : arg1 = 0;
35497 0 : if (jarg1) {
35498 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
35499 0 : if (!arg1) return 0;
35500 : }
35501 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
35502 0 : arg3 = *(GDALTranslateOptions **)&jarg3;
35503 : {
35504 0 : if (!arg1) {
35505 : {
35506 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35507 : };
35508 : }
35509 : }
35510 : {
35511 0 : if (!arg2) {
35512 : {
35513 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35514 : };
35515 : }
35516 : }
35517 0 : result = (GDALDatasetShadow *)wrapper_GDALTranslate((char const *)arg1,arg2,arg3);
35518 0 : *(GDALDatasetShadow **)&jresult = result;
35519 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
35520 0 : return jresult;
35521 : }
35522 :
35523 :
35524 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1WarpOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35525 0 : jlong jresult = 0 ;
35526 0 : char **arg1 = (char **) 0 ;
35527 0 : GDALWarpAppOptions *result = 0 ;
35528 :
35529 : (void)jenv;
35530 : (void)jcls;
35531 : {
35532 : /* %typemap(in) char **options */
35533 0 : arg1 = NULL;
35534 0 : if(jarg1 != 0) {
35535 0 : const jclass vector = jenv->FindClass("java/util/Vector");
35536 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35537 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
35538 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35539 : "()Ljava/util/Enumeration;");
35540 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35541 : "hasMoreElements", "()Z");
35542 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35543 : "nextElement", "()Ljava/lang/Object;");
35544 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35545 0 : hasMoreElements == NULL || getNextElement == NULL) {
35546 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35547 0 : return 0;
35548 : }
35549 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35550 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35551 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35552 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35553 : {
35554 0 : CSLDestroy(arg1);
35555 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35556 0 : return 0;
35557 : }
35558 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35559 0 : arg1 = CSLAddString(arg1, valptr);
35560 0 : jenv->ReleaseStringUTFChars(value, valptr);
35561 : }
35562 : }
35563 : }
35564 0 : result = (GDALWarpAppOptions *)new_GDALWarpAppOptions(arg1);
35565 0 : *(GDALWarpAppOptions **)&jresult = result;
35566 : {
35567 : /* %typemap(freearg) char **options */
35568 0 : CSLDestroy( arg1 );
35569 : }
35570 0 : return jresult;
35571 : }
35572 :
35573 :
35574 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1WarpOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35575 0 : GDALWarpAppOptions *arg1 = (GDALWarpAppOptions *) 0 ;
35576 :
35577 : (void)jenv;
35578 : (void)jcls;
35579 0 : arg1 = *(GDALWarpAppOptions **)&jarg1;
35580 0 : delete_GDALWarpAppOptions(arg1);
35581 0 : }
35582 :
35583 :
35584 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Warp_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jlong jarg4, jobject jarg4_, jobject jarg5) {
35585 0 : jint jresult = 0 ;
35586 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35587 : int arg2 ;
35588 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
35589 0 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
35590 : GDALProgressFunc arg5 ;
35591 0 : void *arg6 = (void *) 0 ;
35592 : int result;
35593 :
35594 : (void)jenv;
35595 : (void)jcls;
35596 : JavaProgressData sProgressInfo;
35597 0 : sProgressInfo.jenv = jenv;
35598 0 : sProgressInfo.pJavaCallback = NULL;
35599 : (void)jarg1_;
35600 : (void)jarg4_;
35601 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35602 : {
35603 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
35604 : /* check if is List */
35605 0 : if (jarg2)
35606 : {
35607 0 : arg2 = jenv->GetArrayLength(jarg2);
35608 0 : if (arg2 == 0)
35609 0 : arg3 = NULL;
35610 : else
35611 : {
35612 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
35613 : int i;
35614 0 : for (i=0; i<arg2; i++) {
35615 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
35616 0 : if (obj == NULL)
35617 : {
35618 0 : free (arg3 );
35619 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
35620 0 : return 0;
35621 : }
35622 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
35623 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
35624 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
35625 : }
35626 : }
35627 : }
35628 : else
35629 : {
35630 0 : arg2 = 0;
35631 0 : arg3 = NULL;
35632 : }
35633 : }
35634 0 : arg4 = *(GDALWarpAppOptions **)&jarg4;
35635 : {
35636 0 : if ( jarg5 != 0 ) {
35637 0 : sProgressInfo.pJavaCallback = jarg5;
35638 0 : arg5 = JavaProgressProxy;
35639 0 : arg6 = &sProgressInfo;
35640 : }
35641 : else
35642 : {
35643 0 : arg5 = NULL;
35644 0 : arg6 = NULL;
35645 : }
35646 : }
35647 : {
35648 0 : if (!arg1) {
35649 : {
35650 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35651 : };
35652 : }
35653 : }
35654 0 : result = (int)wrapper_GDALWarpDestDS(arg1,arg2,arg3,arg4,arg5,arg6);
35655 0 : jresult = (jint)result;
35656 : {
35657 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
35658 : }
35659 : {
35660 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
35661 0 : if (arg3) {
35662 0 : free((void*) arg3);
35663 : }
35664 : }
35665 0 : return jresult;
35666 : }
35667 :
35668 :
35669 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Warp_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobjectArray jarg2, jlong jarg4, jobject jarg4_) {
35670 0 : jint jresult = 0 ;
35671 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35672 : int arg2 ;
35673 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
35674 0 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
35675 : int result;
35676 :
35677 : (void)jenv;
35678 : (void)jcls;
35679 : (void)jarg1_;
35680 : (void)jarg4_;
35681 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35682 : {
35683 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
35684 : /* check if is List */
35685 0 : if (jarg2)
35686 : {
35687 0 : arg2 = jenv->GetArrayLength(jarg2);
35688 0 : if (arg2 == 0)
35689 0 : arg3 = NULL;
35690 : else
35691 : {
35692 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
35693 : int i;
35694 0 : for (i=0; i<arg2; i++) {
35695 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
35696 0 : if (obj == NULL)
35697 : {
35698 0 : free (arg3 );
35699 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
35700 0 : return 0;
35701 : }
35702 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
35703 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
35704 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
35705 : }
35706 : }
35707 : }
35708 : else
35709 : {
35710 0 : arg2 = 0;
35711 0 : arg3 = NULL;
35712 : }
35713 : }
35714 0 : arg4 = *(GDALWarpAppOptions **)&jarg4;
35715 : {
35716 0 : if (!arg1) {
35717 : {
35718 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35719 : };
35720 : }
35721 : }
35722 0 : result = (int)wrapper_GDALWarpDestDS(arg1,arg2,arg3,arg4);
35723 0 : jresult = (jint)result;
35724 : {
35725 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
35726 : }
35727 : {
35728 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
35729 0 : if (arg3) {
35730 0 : free((void*) arg3);
35731 : }
35732 : }
35733 0 : return jresult;
35734 : }
35735 :
35736 :
35737 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Warp_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_, jobject jarg5) {
35738 0 : jlong jresult = 0 ;
35739 0 : char *arg1 = (char *) 0 ;
35740 : int arg2 ;
35741 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
35742 0 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
35743 : GDALProgressFunc arg5 ;
35744 0 : void *arg6 = (void *) 0 ;
35745 0 : GDALDatasetShadow *result = 0 ;
35746 :
35747 : (void)jenv;
35748 : (void)jcls;
35749 : JavaProgressData sProgressInfo;
35750 0 : sProgressInfo.jenv = jenv;
35751 0 : sProgressInfo.pJavaCallback = NULL;
35752 : (void)jarg4_;
35753 0 : arg1 = 0;
35754 0 : if (jarg1) {
35755 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
35756 0 : if (!arg1) return 0;
35757 : }
35758 : {
35759 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
35760 : /* check if is List */
35761 0 : if (jarg2)
35762 : {
35763 0 : arg2 = jenv->GetArrayLength(jarg2);
35764 0 : if (arg2 == 0)
35765 0 : arg3 = NULL;
35766 : else
35767 : {
35768 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
35769 : int i;
35770 0 : for (i=0; i<arg2; i++) {
35771 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
35772 0 : if (obj == NULL)
35773 : {
35774 0 : free (arg3 );
35775 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
35776 0 : return 0;
35777 : }
35778 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
35779 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
35780 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
35781 : }
35782 : }
35783 : }
35784 : else
35785 : {
35786 0 : arg2 = 0;
35787 0 : arg3 = NULL;
35788 : }
35789 : }
35790 0 : arg4 = *(GDALWarpAppOptions **)&jarg4;
35791 : {
35792 0 : if ( jarg5 != 0 ) {
35793 0 : sProgressInfo.pJavaCallback = jarg5;
35794 0 : arg5 = JavaProgressProxy;
35795 0 : arg6 = &sProgressInfo;
35796 : }
35797 : else
35798 : {
35799 0 : arg5 = NULL;
35800 0 : arg6 = NULL;
35801 : }
35802 : }
35803 : {
35804 0 : if (!arg1) {
35805 : {
35806 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35807 : };
35808 : }
35809 : }
35810 0 : result = (GDALDatasetShadow *)wrapper_GDALWarpDestName((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
35811 0 : *(GDALDatasetShadow **)&jresult = result;
35812 : {
35813 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
35814 : }
35815 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
35816 : {
35817 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
35818 0 : if (arg3) {
35819 0 : free((void*) arg3);
35820 : }
35821 : }
35822 0 : return jresult;
35823 : }
35824 :
35825 :
35826 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Warp_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_) {
35827 0 : jlong jresult = 0 ;
35828 0 : char *arg1 = (char *) 0 ;
35829 : int arg2 ;
35830 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
35831 0 : GDALWarpAppOptions *arg4 = (GDALWarpAppOptions *) 0 ;
35832 0 : GDALDatasetShadow *result = 0 ;
35833 :
35834 : (void)jenv;
35835 : (void)jcls;
35836 : (void)jarg4_;
35837 0 : arg1 = 0;
35838 0 : if (jarg1) {
35839 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
35840 0 : if (!arg1) return 0;
35841 : }
35842 : {
35843 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
35844 : /* check if is List */
35845 0 : if (jarg2)
35846 : {
35847 0 : arg2 = jenv->GetArrayLength(jarg2);
35848 0 : if (arg2 == 0)
35849 0 : arg3 = NULL;
35850 : else
35851 : {
35852 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
35853 : int i;
35854 0 : for (i=0; i<arg2; i++) {
35855 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
35856 0 : if (obj == NULL)
35857 : {
35858 0 : free (arg3 );
35859 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
35860 0 : return 0;
35861 : }
35862 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
35863 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
35864 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
35865 : }
35866 : }
35867 : }
35868 : else
35869 : {
35870 0 : arg2 = 0;
35871 0 : arg3 = NULL;
35872 : }
35873 : }
35874 0 : arg4 = *(GDALWarpAppOptions **)&jarg4;
35875 : {
35876 0 : if (!arg1) {
35877 : {
35878 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
35879 : };
35880 : }
35881 : }
35882 0 : result = (GDALDatasetShadow *)wrapper_GDALWarpDestName((char const *)arg1,arg2,arg3,arg4);
35883 0 : *(GDALDatasetShadow **)&jresult = result;
35884 : {
35885 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
35886 : }
35887 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
35888 : {
35889 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
35890 0 : if (arg3) {
35891 0 : free((void*) arg3);
35892 : }
35893 : }
35894 0 : return jresult;
35895 : }
35896 :
35897 :
35898 2 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1VectorTranslateOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
35899 2 : jlong jresult = 0 ;
35900 2 : char **arg1 = (char **) 0 ;
35901 2 : GDALVectorTranslateOptions *result = 0 ;
35902 :
35903 : (void)jenv;
35904 : (void)jcls;
35905 : {
35906 : /* %typemap(in) char **options */
35907 2 : arg1 = NULL;
35908 2 : if(jarg1 != 0) {
35909 2 : const jclass vector = jenv->FindClass("java/util/Vector");
35910 2 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
35911 2 : const jclass stringClass = jenv->FindClass("java/lang/String");
35912 2 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
35913 : "()Ljava/util/Enumeration;");
35914 2 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
35915 : "hasMoreElements", "()Z");
35916 2 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
35917 : "nextElement", "()Ljava/lang/Object;");
35918 2 : if(vector == NULL || enumeration == NULL || elements == NULL ||
35919 2 : hasMoreElements == NULL || getNextElement == NULL) {
35920 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
35921 0 : return 0;
35922 : }
35923 5 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
35924 5 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
35925 3 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
35926 3 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
35927 : {
35928 0 : CSLDestroy(arg1);
35929 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
35930 0 : return 0;
35931 : }
35932 3 : const char *valptr = jenv->GetStringUTFChars(value, 0);
35933 3 : arg1 = CSLAddString(arg1, valptr);
35934 3 : jenv->ReleaseStringUTFChars(value, valptr);
35935 : }
35936 : }
35937 : }
35938 2 : result = (GDALVectorTranslateOptions *)new_GDALVectorTranslateOptions(arg1);
35939 2 : *(GDALVectorTranslateOptions **)&jresult = result;
35940 : {
35941 : /* %typemap(freearg) char **options */
35942 2 : CSLDestroy( arg1 );
35943 : }
35944 2 : return jresult;
35945 : }
35946 :
35947 :
35948 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1VectorTranslateOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
35949 0 : GDALVectorTranslateOptions *arg1 = (GDALVectorTranslateOptions *) 0 ;
35950 :
35951 : (void)jenv;
35952 : (void)jcls;
35953 0 : arg1 = *(GDALVectorTranslateOptions **)&jarg1;
35954 0 : delete_GDALVectorTranslateOptions(arg1);
35955 0 : }
35956 :
35957 :
35958 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_VectorTranslate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
35959 0 : jint jresult = 0 ;
35960 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35961 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
35962 0 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
35963 : GDALProgressFunc arg4 ;
35964 0 : void *arg5 = (void *) 0 ;
35965 : int result;
35966 :
35967 : (void)jenv;
35968 : (void)jcls;
35969 : JavaProgressData sProgressInfo;
35970 0 : sProgressInfo.jenv = jenv;
35971 0 : sProgressInfo.pJavaCallback = NULL;
35972 : (void)jarg1_;
35973 : (void)jarg2_;
35974 : (void)jarg3_;
35975 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
35976 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
35977 0 : arg3 = *(GDALVectorTranslateOptions **)&jarg3;
35978 : {
35979 0 : if ( jarg4 != 0 ) {
35980 0 : sProgressInfo.pJavaCallback = jarg4;
35981 0 : arg4 = JavaProgressProxy;
35982 0 : arg5 = &sProgressInfo;
35983 : }
35984 : else
35985 : {
35986 0 : arg4 = NULL;
35987 0 : arg5 = NULL;
35988 : }
35989 : }
35990 0 : result = (int)wrapper_GDALVectorTranslateDestDS(arg1,arg2,arg3,arg4,arg5);
35991 0 : jresult = (jint)result;
35992 0 : return jresult;
35993 : }
35994 :
35995 :
35996 1 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_VectorTranslate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
35997 1 : jint jresult = 0 ;
35998 1 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
35999 1 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36000 1 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
36001 : int result;
36002 :
36003 : (void)jenv;
36004 : (void)jcls;
36005 : (void)jarg1_;
36006 : (void)jarg2_;
36007 : (void)jarg3_;
36008 1 : arg1 = *(GDALDatasetShadow **)&jarg1;
36009 1 : arg2 = *(GDALDatasetShadow **)&jarg2;
36010 1 : arg3 = *(GDALVectorTranslateOptions **)&jarg3;
36011 1 : result = (int)wrapper_GDALVectorTranslateDestDS(arg1,arg2,arg3);
36012 1 : jresult = (jint)result;
36013 1 : return jresult;
36014 : }
36015 :
36016 :
36017 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_VectorTranslate_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36018 0 : jlong jresult = 0 ;
36019 0 : char *arg1 = (char *) 0 ;
36020 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36021 0 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
36022 : GDALProgressFunc arg4 ;
36023 0 : void *arg5 = (void *) 0 ;
36024 0 : GDALDatasetShadow *result = 0 ;
36025 :
36026 : (void)jenv;
36027 : (void)jcls;
36028 : JavaProgressData sProgressInfo;
36029 0 : sProgressInfo.jenv = jenv;
36030 0 : sProgressInfo.pJavaCallback = NULL;
36031 : (void)jarg2_;
36032 : (void)jarg3_;
36033 0 : arg1 = 0;
36034 0 : if (jarg1) {
36035 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36036 0 : if (!arg1) return 0;
36037 : }
36038 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36039 0 : arg3 = *(GDALVectorTranslateOptions **)&jarg3;
36040 : {
36041 0 : if ( jarg4 != 0 ) {
36042 0 : sProgressInfo.pJavaCallback = jarg4;
36043 0 : arg4 = JavaProgressProxy;
36044 0 : arg5 = &sProgressInfo;
36045 : }
36046 : else
36047 : {
36048 0 : arg4 = NULL;
36049 0 : arg5 = NULL;
36050 : }
36051 : }
36052 : {
36053 0 : if (!arg1) {
36054 : {
36055 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36056 : };
36057 : }
36058 : }
36059 0 : result = (GDALDatasetShadow *)wrapper_GDALVectorTranslateDestName((char const *)arg1,arg2,arg3,arg4,arg5);
36060 0 : *(GDALDatasetShadow **)&jresult = result;
36061 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36062 0 : return jresult;
36063 : }
36064 :
36065 :
36066 1 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_VectorTranslate_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36067 1 : jlong jresult = 0 ;
36068 1 : char *arg1 = (char *) 0 ;
36069 1 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36070 1 : GDALVectorTranslateOptions *arg3 = (GDALVectorTranslateOptions *) 0 ;
36071 1 : GDALDatasetShadow *result = 0 ;
36072 :
36073 : (void)jenv;
36074 : (void)jcls;
36075 : (void)jarg2_;
36076 : (void)jarg3_;
36077 1 : arg1 = 0;
36078 1 : if (jarg1) {
36079 1 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36080 1 : if (!arg1) return 0;
36081 : }
36082 1 : arg2 = *(GDALDatasetShadow **)&jarg2;
36083 1 : arg3 = *(GDALVectorTranslateOptions **)&jarg3;
36084 : {
36085 1 : if (!arg1) {
36086 : {
36087 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36088 : };
36089 : }
36090 : }
36091 1 : result = (GDALDatasetShadow *)wrapper_GDALVectorTranslateDestName((char const *)arg1,arg2,arg3);
36092 1 : *(GDALDatasetShadow **)&jresult = result;
36093 1 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36094 1 : return jresult;
36095 : }
36096 :
36097 :
36098 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1DEMProcessingOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
36099 0 : jlong jresult = 0 ;
36100 0 : char **arg1 = (char **) 0 ;
36101 0 : GDALDEMProcessingOptions *result = 0 ;
36102 :
36103 : (void)jenv;
36104 : (void)jcls;
36105 : {
36106 : /* %typemap(in) char **options */
36107 0 : arg1 = NULL;
36108 0 : if(jarg1 != 0) {
36109 0 : const jclass vector = jenv->FindClass("java/util/Vector");
36110 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
36111 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
36112 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
36113 : "()Ljava/util/Enumeration;");
36114 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
36115 : "hasMoreElements", "()Z");
36116 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
36117 : "nextElement", "()Ljava/lang/Object;");
36118 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
36119 0 : hasMoreElements == NULL || getNextElement == NULL) {
36120 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
36121 0 : return 0;
36122 : }
36123 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
36124 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
36125 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
36126 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
36127 : {
36128 0 : CSLDestroy(arg1);
36129 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
36130 0 : return 0;
36131 : }
36132 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
36133 0 : arg1 = CSLAddString(arg1, valptr);
36134 0 : jenv->ReleaseStringUTFChars(value, valptr);
36135 : }
36136 : }
36137 : }
36138 0 : result = (GDALDEMProcessingOptions *)new_GDALDEMProcessingOptions(arg1);
36139 0 : *(GDALDEMProcessingOptions **)&jresult = result;
36140 : {
36141 : /* %typemap(freearg) char **options */
36142 0 : CSLDestroy( arg1 );
36143 : }
36144 0 : return jresult;
36145 : }
36146 :
36147 :
36148 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1DEMProcessingOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
36149 0 : GDALDEMProcessingOptions *arg1 = (GDALDEMProcessingOptions *) 0 ;
36150 :
36151 : (void)jenv;
36152 : (void)jcls;
36153 0 : arg1 = *(GDALDEMProcessingOptions **)&jarg1;
36154 0 : delete_GDALDEMProcessingOptions(arg1);
36155 0 : }
36156 :
36157 :
36158 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_DEMProcessing_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jlong jarg5, jobject jarg5_, jobject jarg6) {
36159 0 : jlong jresult = 0 ;
36160 0 : char *arg1 = (char *) 0 ;
36161 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36162 0 : char *arg3 = (char *) 0 ;
36163 0 : char *arg4 = (char *) 0 ;
36164 0 : GDALDEMProcessingOptions *arg5 = (GDALDEMProcessingOptions *) 0 ;
36165 : GDALProgressFunc arg6 ;
36166 0 : void *arg7 = (void *) 0 ;
36167 0 : GDALDatasetShadow *result = 0 ;
36168 :
36169 : (void)jenv;
36170 : (void)jcls;
36171 : JavaProgressData sProgressInfo;
36172 0 : sProgressInfo.jenv = jenv;
36173 0 : sProgressInfo.pJavaCallback = NULL;
36174 : (void)jarg2_;
36175 : (void)jarg5_;
36176 0 : arg1 = 0;
36177 0 : if (jarg1) {
36178 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36179 0 : if (!arg1) return 0;
36180 : }
36181 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36182 0 : arg3 = 0;
36183 0 : if (jarg3) {
36184 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
36185 0 : if (!arg3) return 0;
36186 : }
36187 0 : arg4 = 0;
36188 0 : if (jarg4) {
36189 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
36190 0 : if (!arg4) return 0;
36191 : }
36192 0 : arg5 = *(GDALDEMProcessingOptions **)&jarg5;
36193 : {
36194 0 : if ( jarg6 != 0 ) {
36195 0 : sProgressInfo.pJavaCallback = jarg6;
36196 0 : arg6 = JavaProgressProxy;
36197 0 : arg7 = &sProgressInfo;
36198 : }
36199 : else
36200 : {
36201 0 : arg6 = NULL;
36202 0 : arg7 = NULL;
36203 : }
36204 : }
36205 : {
36206 0 : if (!arg1) {
36207 : {
36208 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36209 : };
36210 : }
36211 : }
36212 : {
36213 0 : if (!arg2) {
36214 : {
36215 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36216 : };
36217 : }
36218 : }
36219 : {
36220 0 : if (!arg3) {
36221 : {
36222 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36223 : };
36224 : }
36225 : }
36226 0 : result = (GDALDatasetShadow *)wrapper_GDALDEMProcessing((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5,arg6,arg7);
36227 0 : *(GDALDatasetShadow **)&jresult = result;
36228 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36229 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
36230 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
36231 0 : return jresult;
36232 : }
36233 :
36234 :
36235 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_DEMProcessing_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jstring jarg3, jstring jarg4, jlong jarg5, jobject jarg5_) {
36236 0 : jlong jresult = 0 ;
36237 0 : char *arg1 = (char *) 0 ;
36238 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36239 0 : char *arg3 = (char *) 0 ;
36240 0 : char *arg4 = (char *) 0 ;
36241 0 : GDALDEMProcessingOptions *arg5 = (GDALDEMProcessingOptions *) 0 ;
36242 0 : GDALDatasetShadow *result = 0 ;
36243 :
36244 : (void)jenv;
36245 : (void)jcls;
36246 : (void)jarg2_;
36247 : (void)jarg5_;
36248 0 : arg1 = 0;
36249 0 : if (jarg1) {
36250 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36251 0 : if (!arg1) return 0;
36252 : }
36253 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36254 0 : arg3 = 0;
36255 0 : if (jarg3) {
36256 0 : arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
36257 0 : if (!arg3) return 0;
36258 : }
36259 0 : arg4 = 0;
36260 0 : if (jarg4) {
36261 0 : arg4 = (char *)jenv->GetStringUTFChars(jarg4, 0);
36262 0 : if (!arg4) return 0;
36263 : }
36264 0 : arg5 = *(GDALDEMProcessingOptions **)&jarg5;
36265 : {
36266 0 : if (!arg1) {
36267 : {
36268 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36269 : };
36270 : }
36271 : }
36272 : {
36273 0 : if (!arg2) {
36274 : {
36275 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36276 : };
36277 : }
36278 : }
36279 : {
36280 0 : if (!arg3) {
36281 : {
36282 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36283 : };
36284 : }
36285 : }
36286 0 : result = (GDALDatasetShadow *)wrapper_GDALDEMProcessing((char const *)arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
36287 0 : *(GDALDatasetShadow **)&jresult = result;
36288 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36289 0 : if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
36290 0 : if (arg4) jenv->ReleaseStringUTFChars(jarg4, (const char *)arg4);
36291 0 : return jresult;
36292 : }
36293 :
36294 :
36295 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1NearblackOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
36296 0 : jlong jresult = 0 ;
36297 0 : char **arg1 = (char **) 0 ;
36298 0 : GDALNearblackOptions *result = 0 ;
36299 :
36300 : (void)jenv;
36301 : (void)jcls;
36302 : {
36303 : /* %typemap(in) char **options */
36304 0 : arg1 = NULL;
36305 0 : if(jarg1 != 0) {
36306 0 : const jclass vector = jenv->FindClass("java/util/Vector");
36307 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
36308 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
36309 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
36310 : "()Ljava/util/Enumeration;");
36311 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
36312 : "hasMoreElements", "()Z");
36313 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
36314 : "nextElement", "()Ljava/lang/Object;");
36315 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
36316 0 : hasMoreElements == NULL || getNextElement == NULL) {
36317 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
36318 0 : return 0;
36319 : }
36320 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
36321 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
36322 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
36323 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
36324 : {
36325 0 : CSLDestroy(arg1);
36326 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
36327 0 : return 0;
36328 : }
36329 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
36330 0 : arg1 = CSLAddString(arg1, valptr);
36331 0 : jenv->ReleaseStringUTFChars(value, valptr);
36332 : }
36333 : }
36334 : }
36335 0 : result = (GDALNearblackOptions *)new_GDALNearblackOptions(arg1);
36336 0 : *(GDALNearblackOptions **)&jresult = result;
36337 : {
36338 : /* %typemap(freearg) char **options */
36339 0 : CSLDestroy( arg1 );
36340 : }
36341 0 : return jresult;
36342 : }
36343 :
36344 :
36345 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1NearblackOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
36346 0 : GDALNearblackOptions *arg1 = (GDALNearblackOptions *) 0 ;
36347 :
36348 : (void)jenv;
36349 : (void)jcls;
36350 0 : arg1 = *(GDALNearblackOptions **)&jarg1;
36351 0 : delete_GDALNearblackOptions(arg1);
36352 0 : }
36353 :
36354 :
36355 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Nearblack_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36356 0 : jint jresult = 0 ;
36357 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36358 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36359 0 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
36360 : GDALProgressFunc arg4 ;
36361 0 : void *arg5 = (void *) 0 ;
36362 : int result;
36363 :
36364 : (void)jenv;
36365 : (void)jcls;
36366 : JavaProgressData sProgressInfo;
36367 0 : sProgressInfo.jenv = jenv;
36368 0 : sProgressInfo.pJavaCallback = NULL;
36369 : (void)jarg1_;
36370 : (void)jarg2_;
36371 : (void)jarg3_;
36372 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36373 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36374 0 : arg3 = *(GDALNearblackOptions **)&jarg3;
36375 : {
36376 0 : if ( jarg4 != 0 ) {
36377 0 : sProgressInfo.pJavaCallback = jarg4;
36378 0 : arg4 = JavaProgressProxy;
36379 0 : arg5 = &sProgressInfo;
36380 : }
36381 : else
36382 : {
36383 0 : arg4 = NULL;
36384 0 : arg5 = NULL;
36385 : }
36386 : }
36387 0 : result = (int)wrapper_GDALNearblackDestDS(arg1,arg2,arg3,arg4,arg5);
36388 0 : jresult = (jint)result;
36389 0 : return jresult;
36390 : }
36391 :
36392 :
36393 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Nearblack_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36394 0 : jint jresult = 0 ;
36395 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36396 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36397 0 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
36398 : int result;
36399 :
36400 : (void)jenv;
36401 : (void)jcls;
36402 : (void)jarg1_;
36403 : (void)jarg2_;
36404 : (void)jarg3_;
36405 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36406 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36407 0 : arg3 = *(GDALNearblackOptions **)&jarg3;
36408 0 : result = (int)wrapper_GDALNearblackDestDS(arg1,arg2,arg3);
36409 0 : jresult = (jint)result;
36410 0 : return jresult;
36411 : }
36412 :
36413 :
36414 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Nearblack_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36415 0 : jlong jresult = 0 ;
36416 0 : char *arg1 = (char *) 0 ;
36417 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36418 0 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
36419 : GDALProgressFunc arg4 ;
36420 0 : void *arg5 = (void *) 0 ;
36421 0 : GDALDatasetShadow *result = 0 ;
36422 :
36423 : (void)jenv;
36424 : (void)jcls;
36425 : JavaProgressData sProgressInfo;
36426 0 : sProgressInfo.jenv = jenv;
36427 0 : sProgressInfo.pJavaCallback = NULL;
36428 : (void)jarg2_;
36429 : (void)jarg3_;
36430 0 : arg1 = 0;
36431 0 : if (jarg1) {
36432 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36433 0 : if (!arg1) return 0;
36434 : }
36435 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36436 0 : arg3 = *(GDALNearblackOptions **)&jarg3;
36437 : {
36438 0 : if ( jarg4 != 0 ) {
36439 0 : sProgressInfo.pJavaCallback = jarg4;
36440 0 : arg4 = JavaProgressProxy;
36441 0 : arg5 = &sProgressInfo;
36442 : }
36443 : else
36444 : {
36445 0 : arg4 = NULL;
36446 0 : arg5 = NULL;
36447 : }
36448 : }
36449 : {
36450 0 : if (!arg1) {
36451 : {
36452 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36453 : };
36454 : }
36455 : }
36456 0 : result = (GDALDatasetShadow *)wrapper_GDALNearblackDestName((char const *)arg1,arg2,arg3,arg4,arg5);
36457 0 : *(GDALDatasetShadow **)&jresult = result;
36458 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36459 0 : return jresult;
36460 : }
36461 :
36462 :
36463 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Nearblack_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36464 0 : jlong jresult = 0 ;
36465 0 : char *arg1 = (char *) 0 ;
36466 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36467 0 : GDALNearblackOptions *arg3 = (GDALNearblackOptions *) 0 ;
36468 0 : GDALDatasetShadow *result = 0 ;
36469 :
36470 : (void)jenv;
36471 : (void)jcls;
36472 : (void)jarg2_;
36473 : (void)jarg3_;
36474 0 : arg1 = 0;
36475 0 : if (jarg1) {
36476 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36477 0 : if (!arg1) return 0;
36478 : }
36479 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36480 0 : arg3 = *(GDALNearblackOptions **)&jarg3;
36481 : {
36482 0 : if (!arg1) {
36483 : {
36484 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36485 : };
36486 : }
36487 : }
36488 0 : result = (GDALDatasetShadow *)wrapper_GDALNearblackDestName((char const *)arg1,arg2,arg3);
36489 0 : *(GDALDatasetShadow **)&jresult = result;
36490 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36491 0 : return jresult;
36492 : }
36493 :
36494 :
36495 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1GridOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
36496 0 : jlong jresult = 0 ;
36497 0 : char **arg1 = (char **) 0 ;
36498 0 : GDALGridOptions *result = 0 ;
36499 :
36500 : (void)jenv;
36501 : (void)jcls;
36502 : {
36503 : /* %typemap(in) char **options */
36504 0 : arg1 = NULL;
36505 0 : if(jarg1 != 0) {
36506 0 : const jclass vector = jenv->FindClass("java/util/Vector");
36507 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
36508 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
36509 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
36510 : "()Ljava/util/Enumeration;");
36511 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
36512 : "hasMoreElements", "()Z");
36513 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
36514 : "nextElement", "()Ljava/lang/Object;");
36515 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
36516 0 : hasMoreElements == NULL || getNextElement == NULL) {
36517 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
36518 0 : return 0;
36519 : }
36520 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
36521 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
36522 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
36523 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
36524 : {
36525 0 : CSLDestroy(arg1);
36526 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
36527 0 : return 0;
36528 : }
36529 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
36530 0 : arg1 = CSLAddString(arg1, valptr);
36531 0 : jenv->ReleaseStringUTFChars(value, valptr);
36532 : }
36533 : }
36534 : }
36535 0 : result = (GDALGridOptions *)new_GDALGridOptions(arg1);
36536 0 : *(GDALGridOptions **)&jresult = result;
36537 : {
36538 : /* %typemap(freearg) char **options */
36539 0 : CSLDestroy( arg1 );
36540 : }
36541 0 : return jresult;
36542 : }
36543 :
36544 :
36545 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1GridOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
36546 0 : GDALGridOptions *arg1 = (GDALGridOptions *) 0 ;
36547 :
36548 : (void)jenv;
36549 : (void)jcls;
36550 0 : arg1 = *(GDALGridOptions **)&jarg1;
36551 0 : delete_GDALGridOptions(arg1);
36552 0 : }
36553 :
36554 :
36555 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Grid_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36556 0 : jlong jresult = 0 ;
36557 0 : char *arg1 = (char *) 0 ;
36558 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36559 0 : GDALGridOptions *arg3 = (GDALGridOptions *) 0 ;
36560 : GDALProgressFunc arg4 ;
36561 0 : void *arg5 = (void *) 0 ;
36562 0 : GDALDatasetShadow *result = 0 ;
36563 :
36564 : (void)jenv;
36565 : (void)jcls;
36566 : JavaProgressData sProgressInfo;
36567 0 : sProgressInfo.jenv = jenv;
36568 0 : sProgressInfo.pJavaCallback = NULL;
36569 : (void)jarg2_;
36570 : (void)jarg3_;
36571 0 : arg1 = 0;
36572 0 : if (jarg1) {
36573 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36574 0 : if (!arg1) return 0;
36575 : }
36576 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36577 0 : arg3 = *(GDALGridOptions **)&jarg3;
36578 : {
36579 0 : if ( jarg4 != 0 ) {
36580 0 : sProgressInfo.pJavaCallback = jarg4;
36581 0 : arg4 = JavaProgressProxy;
36582 0 : arg5 = &sProgressInfo;
36583 : }
36584 : else
36585 : {
36586 0 : arg4 = NULL;
36587 0 : arg5 = NULL;
36588 : }
36589 : }
36590 : {
36591 0 : if (!arg1) {
36592 : {
36593 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36594 : };
36595 : }
36596 : }
36597 : {
36598 0 : if (!arg2) {
36599 : {
36600 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36601 : };
36602 : }
36603 : }
36604 0 : result = (GDALDatasetShadow *)wrapper_GDALGrid((char const *)arg1,arg2,arg3,arg4,arg5);
36605 0 : *(GDALDatasetShadow **)&jresult = result;
36606 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36607 0 : return jresult;
36608 : }
36609 :
36610 :
36611 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Grid_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36612 0 : jlong jresult = 0 ;
36613 0 : char *arg1 = (char *) 0 ;
36614 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36615 0 : GDALGridOptions *arg3 = (GDALGridOptions *) 0 ;
36616 0 : GDALDatasetShadow *result = 0 ;
36617 :
36618 : (void)jenv;
36619 : (void)jcls;
36620 : (void)jarg2_;
36621 : (void)jarg3_;
36622 0 : arg1 = 0;
36623 0 : if (jarg1) {
36624 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36625 0 : if (!arg1) return 0;
36626 : }
36627 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36628 0 : arg3 = *(GDALGridOptions **)&jarg3;
36629 : {
36630 0 : if (!arg1) {
36631 : {
36632 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36633 : };
36634 : }
36635 : }
36636 : {
36637 0 : if (!arg2) {
36638 : {
36639 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36640 : };
36641 : }
36642 : }
36643 0 : result = (GDALDatasetShadow *)wrapper_GDALGrid((char const *)arg1,arg2,arg3);
36644 0 : *(GDALDatasetShadow **)&jresult = result;
36645 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36646 0 : return jresult;
36647 : }
36648 :
36649 :
36650 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1RasterizeOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
36651 0 : jlong jresult = 0 ;
36652 0 : char **arg1 = (char **) 0 ;
36653 0 : GDALRasterizeOptions *result = 0 ;
36654 :
36655 : (void)jenv;
36656 : (void)jcls;
36657 : {
36658 : /* %typemap(in) char **options */
36659 0 : arg1 = NULL;
36660 0 : if(jarg1 != 0) {
36661 0 : const jclass vector = jenv->FindClass("java/util/Vector");
36662 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
36663 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
36664 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
36665 : "()Ljava/util/Enumeration;");
36666 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
36667 : "hasMoreElements", "()Z");
36668 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
36669 : "nextElement", "()Ljava/lang/Object;");
36670 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
36671 0 : hasMoreElements == NULL || getNextElement == NULL) {
36672 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
36673 0 : return 0;
36674 : }
36675 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
36676 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
36677 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
36678 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
36679 : {
36680 0 : CSLDestroy(arg1);
36681 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
36682 0 : return 0;
36683 : }
36684 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
36685 0 : arg1 = CSLAddString(arg1, valptr);
36686 0 : jenv->ReleaseStringUTFChars(value, valptr);
36687 : }
36688 : }
36689 : }
36690 0 : result = (GDALRasterizeOptions *)new_GDALRasterizeOptions(arg1);
36691 0 : *(GDALRasterizeOptions **)&jresult = result;
36692 : {
36693 : /* %typemap(freearg) char **options */
36694 0 : CSLDestroy( arg1 );
36695 : }
36696 0 : return jresult;
36697 : }
36698 :
36699 :
36700 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1RasterizeOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
36701 0 : GDALRasterizeOptions *arg1 = (GDALRasterizeOptions *) 0 ;
36702 :
36703 : (void)jenv;
36704 : (void)jcls;
36705 0 : arg1 = *(GDALRasterizeOptions **)&jarg1;
36706 0 : delete_GDALRasterizeOptions(arg1);
36707 0 : }
36708 :
36709 :
36710 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Rasterize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36711 0 : jint jresult = 0 ;
36712 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36713 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36714 0 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
36715 : GDALProgressFunc arg4 ;
36716 0 : void *arg5 = (void *) 0 ;
36717 : int result;
36718 :
36719 : (void)jenv;
36720 : (void)jcls;
36721 : JavaProgressData sProgressInfo;
36722 0 : sProgressInfo.jenv = jenv;
36723 0 : sProgressInfo.pJavaCallback = NULL;
36724 : (void)jarg1_;
36725 : (void)jarg2_;
36726 : (void)jarg3_;
36727 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36728 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36729 0 : arg3 = *(GDALRasterizeOptions **)&jarg3;
36730 : {
36731 0 : if ( jarg4 != 0 ) {
36732 0 : sProgressInfo.pJavaCallback = jarg4;
36733 0 : arg4 = JavaProgressProxy;
36734 0 : arg5 = &sProgressInfo;
36735 : }
36736 : else
36737 : {
36738 0 : arg4 = NULL;
36739 0 : arg5 = NULL;
36740 : }
36741 : }
36742 0 : result = (int)wrapper_GDALRasterizeDestDS(arg1,arg2,arg3,arg4,arg5);
36743 0 : jresult = (jint)result;
36744 0 : return jresult;
36745 : }
36746 :
36747 :
36748 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Rasterize_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36749 0 : jint jresult = 0 ;
36750 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36751 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36752 0 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
36753 : int result;
36754 :
36755 : (void)jenv;
36756 : (void)jcls;
36757 : (void)jarg1_;
36758 : (void)jarg2_;
36759 : (void)jarg3_;
36760 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36761 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36762 0 : arg3 = *(GDALRasterizeOptions **)&jarg3;
36763 0 : result = (int)wrapper_GDALRasterizeDestDS(arg1,arg2,arg3);
36764 0 : jresult = (jint)result;
36765 0 : return jresult;
36766 : }
36767 :
36768 :
36769 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Rasterize_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36770 0 : jlong jresult = 0 ;
36771 0 : char *arg1 = (char *) 0 ;
36772 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36773 0 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
36774 : GDALProgressFunc arg4 ;
36775 0 : void *arg5 = (void *) 0 ;
36776 0 : GDALDatasetShadow *result = 0 ;
36777 :
36778 : (void)jenv;
36779 : (void)jcls;
36780 : JavaProgressData sProgressInfo;
36781 0 : sProgressInfo.jenv = jenv;
36782 0 : sProgressInfo.pJavaCallback = NULL;
36783 : (void)jarg2_;
36784 : (void)jarg3_;
36785 0 : arg1 = 0;
36786 0 : if (jarg1) {
36787 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36788 0 : if (!arg1) return 0;
36789 : }
36790 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36791 0 : arg3 = *(GDALRasterizeOptions **)&jarg3;
36792 : {
36793 0 : if ( jarg4 != 0 ) {
36794 0 : sProgressInfo.pJavaCallback = jarg4;
36795 0 : arg4 = JavaProgressProxy;
36796 0 : arg5 = &sProgressInfo;
36797 : }
36798 : else
36799 : {
36800 0 : arg4 = NULL;
36801 0 : arg5 = NULL;
36802 : }
36803 : }
36804 : {
36805 0 : if (!arg1) {
36806 : {
36807 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36808 : };
36809 : }
36810 : }
36811 0 : result = (GDALDatasetShadow *)wrapper_GDALRasterizeDestName((char const *)arg1,arg2,arg3,arg4,arg5);
36812 0 : *(GDALDatasetShadow **)&jresult = result;
36813 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36814 0 : return jresult;
36815 : }
36816 :
36817 :
36818 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Rasterize_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36819 0 : jlong jresult = 0 ;
36820 0 : char *arg1 = (char *) 0 ;
36821 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36822 0 : GDALRasterizeOptions *arg3 = (GDALRasterizeOptions *) 0 ;
36823 0 : GDALDatasetShadow *result = 0 ;
36824 :
36825 : (void)jenv;
36826 : (void)jcls;
36827 : (void)jarg2_;
36828 : (void)jarg3_;
36829 0 : arg1 = 0;
36830 0 : if (jarg1) {
36831 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36832 0 : if (!arg1) return 0;
36833 : }
36834 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36835 0 : arg3 = *(GDALRasterizeOptions **)&jarg3;
36836 : {
36837 0 : if (!arg1) {
36838 : {
36839 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
36840 : };
36841 : }
36842 : }
36843 0 : result = (GDALDatasetShadow *)wrapper_GDALRasterizeDestName((char const *)arg1,arg2,arg3);
36844 0 : *(GDALDatasetShadow **)&jresult = result;
36845 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
36846 0 : return jresult;
36847 : }
36848 :
36849 :
36850 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1FootprintOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
36851 0 : jlong jresult = 0 ;
36852 0 : char **arg1 = (char **) 0 ;
36853 0 : GDALFootprintOptions *result = 0 ;
36854 :
36855 : (void)jenv;
36856 : (void)jcls;
36857 : {
36858 : /* %typemap(in) char **options */
36859 0 : arg1 = NULL;
36860 0 : if(jarg1 != 0) {
36861 0 : const jclass vector = jenv->FindClass("java/util/Vector");
36862 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
36863 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
36864 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
36865 : "()Ljava/util/Enumeration;");
36866 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
36867 : "hasMoreElements", "()Z");
36868 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
36869 : "nextElement", "()Ljava/lang/Object;");
36870 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
36871 0 : hasMoreElements == NULL || getNextElement == NULL) {
36872 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
36873 0 : return 0;
36874 : }
36875 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
36876 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
36877 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
36878 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
36879 : {
36880 0 : CSLDestroy(arg1);
36881 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
36882 0 : return 0;
36883 : }
36884 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
36885 0 : arg1 = CSLAddString(arg1, valptr);
36886 0 : jenv->ReleaseStringUTFChars(value, valptr);
36887 : }
36888 : }
36889 : }
36890 0 : result = (GDALFootprintOptions *)new_GDALFootprintOptions(arg1);
36891 0 : *(GDALFootprintOptions **)&jresult = result;
36892 : {
36893 : /* %typemap(freearg) char **options */
36894 0 : CSLDestroy( arg1 );
36895 : }
36896 0 : return jresult;
36897 : }
36898 :
36899 :
36900 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1FootprintOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
36901 0 : GDALFootprintOptions *arg1 = (GDALFootprintOptions *) 0 ;
36902 :
36903 : (void)jenv;
36904 : (void)jcls;
36905 0 : arg1 = *(GDALFootprintOptions **)&jarg1;
36906 0 : delete_GDALFootprintOptions(arg1);
36907 0 : }
36908 :
36909 :
36910 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Footprint_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36911 0 : jint jresult = 0 ;
36912 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36913 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36914 0 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
36915 : GDALProgressFunc arg4 ;
36916 0 : void *arg5 = (void *) 0 ;
36917 : int result;
36918 :
36919 : (void)jenv;
36920 : (void)jcls;
36921 : JavaProgressData sProgressInfo;
36922 0 : sProgressInfo.jenv = jenv;
36923 0 : sProgressInfo.pJavaCallback = NULL;
36924 : (void)jarg1_;
36925 : (void)jarg2_;
36926 : (void)jarg3_;
36927 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36928 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36929 0 : arg3 = *(GDALFootprintOptions **)&jarg3;
36930 : {
36931 0 : if ( jarg4 != 0 ) {
36932 0 : sProgressInfo.pJavaCallback = jarg4;
36933 0 : arg4 = JavaProgressProxy;
36934 0 : arg5 = &sProgressInfo;
36935 : }
36936 : else
36937 : {
36938 0 : arg4 = NULL;
36939 0 : arg5 = NULL;
36940 : }
36941 : }
36942 0 : result = (int)wrapper_GDALFootprintDestDS(arg1,arg2,arg3,arg4,arg5);
36943 0 : jresult = (jint)result;
36944 0 : return jresult;
36945 : }
36946 :
36947 :
36948 0 : SWIGEXPORT jint JNICALL Java_org_gdal_gdal_gdalJNI_Footprint_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
36949 0 : jint jresult = 0 ;
36950 0 : GDALDatasetShadow *arg1 = (GDALDatasetShadow *) 0 ;
36951 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36952 0 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
36953 : int result;
36954 :
36955 : (void)jenv;
36956 : (void)jcls;
36957 : (void)jarg1_;
36958 : (void)jarg2_;
36959 : (void)jarg3_;
36960 0 : arg1 = *(GDALDatasetShadow **)&jarg1;
36961 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36962 0 : arg3 = *(GDALFootprintOptions **)&jarg3;
36963 0 : result = (int)wrapper_GDALFootprintDestDS(arg1,arg2,arg3);
36964 0 : jresult = (jint)result;
36965 0 : return jresult;
36966 : }
36967 :
36968 :
36969 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Footprint_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jobject jarg4) {
36970 0 : jlong jresult = 0 ;
36971 0 : char *arg1 = (char *) 0 ;
36972 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
36973 0 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
36974 : GDALProgressFunc arg4 ;
36975 0 : void *arg5 = (void *) 0 ;
36976 0 : GDALDatasetShadow *result = 0 ;
36977 :
36978 : (void)jenv;
36979 : (void)jcls;
36980 : JavaProgressData sProgressInfo;
36981 0 : sProgressInfo.jenv = jenv;
36982 0 : sProgressInfo.pJavaCallback = NULL;
36983 : (void)jarg2_;
36984 : (void)jarg3_;
36985 0 : arg1 = 0;
36986 0 : if (jarg1) {
36987 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
36988 0 : if (!arg1) return 0;
36989 : }
36990 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
36991 0 : arg3 = *(GDALFootprintOptions **)&jarg3;
36992 : {
36993 0 : if ( jarg4 != 0 ) {
36994 0 : sProgressInfo.pJavaCallback = jarg4;
36995 0 : arg4 = JavaProgressProxy;
36996 0 : arg5 = &sProgressInfo;
36997 : }
36998 : else
36999 : {
37000 0 : arg4 = NULL;
37001 0 : arg5 = NULL;
37002 : }
37003 : }
37004 : {
37005 0 : if (!arg1) {
37006 : {
37007 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37008 : };
37009 : }
37010 : }
37011 0 : result = (GDALDatasetShadow *)wrapper_GDALFootprintDestName((char const *)arg1,arg2,arg3,arg4,arg5);
37012 0 : *(GDALDatasetShadow **)&jresult = result;
37013 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37014 0 : return jresult;
37015 : }
37016 :
37017 :
37018 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Footprint_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
37019 0 : jlong jresult = 0 ;
37020 0 : char *arg1 = (char *) 0 ;
37021 0 : GDALDatasetShadow *arg2 = (GDALDatasetShadow *) 0 ;
37022 0 : GDALFootprintOptions *arg3 = (GDALFootprintOptions *) 0 ;
37023 0 : GDALDatasetShadow *result = 0 ;
37024 :
37025 : (void)jenv;
37026 : (void)jcls;
37027 : (void)jarg2_;
37028 : (void)jarg3_;
37029 0 : arg1 = 0;
37030 0 : if (jarg1) {
37031 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37032 0 : if (!arg1) return 0;
37033 : }
37034 0 : arg2 = *(GDALDatasetShadow **)&jarg2;
37035 0 : arg3 = *(GDALFootprintOptions **)&jarg3;
37036 : {
37037 0 : if (!arg1) {
37038 : {
37039 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37040 : };
37041 : }
37042 : }
37043 0 : result = (GDALDatasetShadow *)wrapper_GDALFootprintDestName((char const *)arg1,arg2,arg3);
37044 0 : *(GDALDatasetShadow **)&jresult = result;
37045 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37046 0 : return jresult;
37047 : }
37048 :
37049 :
37050 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1BuildVRTOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
37051 0 : jlong jresult = 0 ;
37052 0 : char **arg1 = (char **) 0 ;
37053 0 : GDALBuildVRTOptions *result = 0 ;
37054 :
37055 : (void)jenv;
37056 : (void)jcls;
37057 : {
37058 : /* %typemap(in) char **options */
37059 0 : arg1 = NULL;
37060 0 : if(jarg1 != 0) {
37061 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37062 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37063 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37064 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37065 : "()Ljava/util/Enumeration;");
37066 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37067 : "hasMoreElements", "()Z");
37068 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37069 : "nextElement", "()Ljava/lang/Object;");
37070 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37071 0 : hasMoreElements == NULL || getNextElement == NULL) {
37072 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37073 0 : return 0;
37074 : }
37075 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
37076 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37077 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37078 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37079 : {
37080 0 : CSLDestroy(arg1);
37081 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37082 0 : return 0;
37083 : }
37084 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37085 0 : arg1 = CSLAddString(arg1, valptr);
37086 0 : jenv->ReleaseStringUTFChars(value, valptr);
37087 : }
37088 : }
37089 : }
37090 0 : result = (GDALBuildVRTOptions *)new_GDALBuildVRTOptions(arg1);
37091 0 : *(GDALBuildVRTOptions **)&jresult = result;
37092 : {
37093 : /* %typemap(freearg) char **options */
37094 0 : CSLDestroy( arg1 );
37095 : }
37096 0 : return jresult;
37097 : }
37098 :
37099 :
37100 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1BuildVRTOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37101 0 : GDALBuildVRTOptions *arg1 = (GDALBuildVRTOptions *) 0 ;
37102 :
37103 : (void)jenv;
37104 : (void)jcls;
37105 0 : arg1 = *(GDALBuildVRTOptions **)&jarg1;
37106 0 : delete_GDALBuildVRTOptions(arg1);
37107 0 : }
37108 :
37109 :
37110 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_BuildVRT_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_, jobject jarg5) {
37111 0 : jlong jresult = 0 ;
37112 0 : char *arg1 = (char *) 0 ;
37113 : int arg2 ;
37114 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
37115 0 : GDALBuildVRTOptions *arg4 = (GDALBuildVRTOptions *) 0 ;
37116 : GDALProgressFunc arg5 ;
37117 0 : void *arg6 = (void *) 0 ;
37118 0 : GDALDatasetShadow *result = 0 ;
37119 :
37120 : (void)jenv;
37121 : (void)jcls;
37122 : JavaProgressData sProgressInfo;
37123 0 : sProgressInfo.jenv = jenv;
37124 0 : sProgressInfo.pJavaCallback = NULL;
37125 : (void)jarg4_;
37126 0 : arg1 = 0;
37127 0 : if (jarg1) {
37128 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37129 0 : if (!arg1) return 0;
37130 : }
37131 : {
37132 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
37133 : /* check if is List */
37134 0 : if (jarg2)
37135 : {
37136 0 : arg2 = jenv->GetArrayLength(jarg2);
37137 0 : if (arg2 == 0)
37138 0 : arg3 = NULL;
37139 : else
37140 : {
37141 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
37142 : int i;
37143 0 : for (i=0; i<arg2; i++) {
37144 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
37145 0 : if (obj == NULL)
37146 : {
37147 0 : free (arg3 );
37148 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
37149 0 : return 0;
37150 : }
37151 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
37152 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
37153 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
37154 : }
37155 : }
37156 : }
37157 : else
37158 : {
37159 0 : arg2 = 0;
37160 0 : arg3 = NULL;
37161 : }
37162 : }
37163 0 : arg4 = *(GDALBuildVRTOptions **)&jarg4;
37164 : {
37165 0 : if ( jarg5 != 0 ) {
37166 0 : sProgressInfo.pJavaCallback = jarg5;
37167 0 : arg5 = JavaProgressProxy;
37168 0 : arg6 = &sProgressInfo;
37169 : }
37170 : else
37171 : {
37172 0 : arg5 = NULL;
37173 0 : arg6 = NULL;
37174 : }
37175 : }
37176 : {
37177 0 : if (!arg1) {
37178 : {
37179 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37180 : };
37181 : }
37182 : }
37183 0 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_objects((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
37184 0 : *(GDALDatasetShadow **)&jresult = result;
37185 : {
37186 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
37187 : }
37188 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37189 : {
37190 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
37191 0 : if (arg3) {
37192 0 : free((void*) arg3);
37193 : }
37194 : }
37195 0 : return jresult;
37196 : }
37197 :
37198 :
37199 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_BuildVRT_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_) {
37200 0 : jlong jresult = 0 ;
37201 0 : char *arg1 = (char *) 0 ;
37202 : int arg2 ;
37203 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
37204 0 : GDALBuildVRTOptions *arg4 = (GDALBuildVRTOptions *) 0 ;
37205 0 : GDALDatasetShadow *result = 0 ;
37206 :
37207 : (void)jenv;
37208 : (void)jcls;
37209 : (void)jarg4_;
37210 0 : arg1 = 0;
37211 0 : if (jarg1) {
37212 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37213 0 : if (!arg1) return 0;
37214 : }
37215 : {
37216 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
37217 : /* check if is List */
37218 0 : if (jarg2)
37219 : {
37220 0 : arg2 = jenv->GetArrayLength(jarg2);
37221 0 : if (arg2 == 0)
37222 0 : arg3 = NULL;
37223 : else
37224 : {
37225 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
37226 : int i;
37227 0 : for (i=0; i<arg2; i++) {
37228 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
37229 0 : if (obj == NULL)
37230 : {
37231 0 : free (arg3 );
37232 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
37233 0 : return 0;
37234 : }
37235 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
37236 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
37237 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
37238 : }
37239 : }
37240 : }
37241 : else
37242 : {
37243 0 : arg2 = 0;
37244 0 : arg3 = NULL;
37245 : }
37246 : }
37247 0 : arg4 = *(GDALBuildVRTOptions **)&jarg4;
37248 : {
37249 0 : if (!arg1) {
37250 : {
37251 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37252 : };
37253 : }
37254 : }
37255 0 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_objects((char const *)arg1,arg2,arg3,arg4);
37256 0 : *(GDALDatasetShadow **)&jresult = result;
37257 : {
37258 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
37259 : }
37260 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37261 : {
37262 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
37263 0 : if (arg3) {
37264 0 : free((void*) arg3);
37265 : }
37266 : }
37267 0 : return jresult;
37268 : }
37269 :
37270 :
37271 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_BuildVRT_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2, jlong jarg3, jobject jarg3_, jobject jarg4) {
37272 0 : jlong jresult = 0 ;
37273 0 : char *arg1 = (char *) 0 ;
37274 0 : char **arg2 = (char **) 0 ;
37275 0 : GDALBuildVRTOptions *arg3 = (GDALBuildVRTOptions *) 0 ;
37276 : GDALProgressFunc arg4 ;
37277 0 : void *arg5 = (void *) 0 ;
37278 0 : GDALDatasetShadow *result = 0 ;
37279 :
37280 : (void)jenv;
37281 : (void)jcls;
37282 : JavaProgressData sProgressInfo;
37283 0 : sProgressInfo.jenv = jenv;
37284 0 : sProgressInfo.pJavaCallback = NULL;
37285 : (void)jarg3_;
37286 0 : arg1 = 0;
37287 0 : if (jarg1) {
37288 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37289 0 : if (!arg1) return 0;
37290 : }
37291 : {
37292 : /* %typemap(in) char **options */
37293 0 : arg2 = NULL;
37294 0 : if(jarg2 != 0) {
37295 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37296 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37297 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37298 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37299 : "()Ljava/util/Enumeration;");
37300 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37301 : "hasMoreElements", "()Z");
37302 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37303 : "nextElement", "()Ljava/lang/Object;");
37304 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37305 0 : hasMoreElements == NULL || getNextElement == NULL) {
37306 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37307 0 : return 0;
37308 : }
37309 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
37310 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37311 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37312 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37313 : {
37314 0 : CSLDestroy(arg2);
37315 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37316 0 : return 0;
37317 : }
37318 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37319 0 : arg2 = CSLAddString(arg2, valptr);
37320 0 : jenv->ReleaseStringUTFChars(value, valptr);
37321 : }
37322 : }
37323 : }
37324 0 : arg3 = *(GDALBuildVRTOptions **)&jarg3;
37325 : {
37326 0 : if ( jarg4 != 0 ) {
37327 0 : sProgressInfo.pJavaCallback = jarg4;
37328 0 : arg4 = JavaProgressProxy;
37329 0 : arg5 = &sProgressInfo;
37330 : }
37331 : else
37332 : {
37333 0 : arg4 = NULL;
37334 0 : arg5 = NULL;
37335 : }
37336 : }
37337 : {
37338 0 : if (!arg1) {
37339 : {
37340 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37341 : };
37342 : }
37343 : }
37344 0 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_names((char const *)arg1,arg2,arg3,arg4,arg5);
37345 0 : *(GDALDatasetShadow **)&jresult = result;
37346 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37347 : {
37348 : /* %typemap(freearg) char **options */
37349 0 : CSLDestroy( arg2 );
37350 : }
37351 0 : return jresult;
37352 : }
37353 :
37354 :
37355 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_BuildVRT_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2, jlong jarg3, jobject jarg3_) {
37356 0 : jlong jresult = 0 ;
37357 0 : char *arg1 = (char *) 0 ;
37358 0 : char **arg2 = (char **) 0 ;
37359 0 : GDALBuildVRTOptions *arg3 = (GDALBuildVRTOptions *) 0 ;
37360 0 : GDALDatasetShadow *result = 0 ;
37361 :
37362 : (void)jenv;
37363 : (void)jcls;
37364 : (void)jarg3_;
37365 0 : arg1 = 0;
37366 0 : if (jarg1) {
37367 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37368 0 : if (!arg1) return 0;
37369 : }
37370 : {
37371 : /* %typemap(in) char **options */
37372 0 : arg2 = NULL;
37373 0 : if(jarg2 != 0) {
37374 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37375 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37376 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37377 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37378 : "()Ljava/util/Enumeration;");
37379 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37380 : "hasMoreElements", "()Z");
37381 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37382 : "nextElement", "()Ljava/lang/Object;");
37383 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37384 0 : hasMoreElements == NULL || getNextElement == NULL) {
37385 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37386 0 : return 0;
37387 : }
37388 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
37389 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37390 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37391 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37392 : {
37393 0 : CSLDestroy(arg2);
37394 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37395 0 : return 0;
37396 : }
37397 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37398 0 : arg2 = CSLAddString(arg2, valptr);
37399 0 : jenv->ReleaseStringUTFChars(value, valptr);
37400 : }
37401 : }
37402 : }
37403 0 : arg3 = *(GDALBuildVRTOptions **)&jarg3;
37404 : {
37405 0 : if (!arg1) {
37406 : {
37407 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37408 : };
37409 : }
37410 : }
37411 0 : result = (GDALDatasetShadow *)wrapper_GDALBuildVRT_names((char const *)arg1,arg2,arg3);
37412 0 : *(GDALDatasetShadow **)&jresult = result;
37413 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37414 : {
37415 : /* %typemap(freearg) char **options */
37416 0 : CSLDestroy( arg2 );
37417 : }
37418 0 : return jresult;
37419 : }
37420 :
37421 :
37422 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1TileIndexOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
37423 0 : jlong jresult = 0 ;
37424 0 : char **arg1 = (char **) 0 ;
37425 0 : GDALTileIndexOptions *result = 0 ;
37426 :
37427 : (void)jenv;
37428 : (void)jcls;
37429 : {
37430 : /* %typemap(in) char **options */
37431 0 : arg1 = NULL;
37432 0 : if(jarg1 != 0) {
37433 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37434 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37435 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37436 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37437 : "()Ljava/util/Enumeration;");
37438 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37439 : "hasMoreElements", "()Z");
37440 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37441 : "nextElement", "()Ljava/lang/Object;");
37442 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37443 0 : hasMoreElements == NULL || getNextElement == NULL) {
37444 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37445 0 : return 0;
37446 : }
37447 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
37448 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37449 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37450 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37451 : {
37452 0 : CSLDestroy(arg1);
37453 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37454 0 : return 0;
37455 : }
37456 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37457 0 : arg1 = CSLAddString(arg1, valptr);
37458 0 : jenv->ReleaseStringUTFChars(value, valptr);
37459 : }
37460 : }
37461 : }
37462 0 : result = (GDALTileIndexOptions *)new_GDALTileIndexOptions(arg1);
37463 0 : *(GDALTileIndexOptions **)&jresult = result;
37464 : {
37465 : /* %typemap(freearg) char **options */
37466 0 : CSLDestroy( arg1 );
37467 : }
37468 0 : return jresult;
37469 : }
37470 :
37471 :
37472 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1TileIndexOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37473 0 : GDALTileIndexOptions *arg1 = (GDALTileIndexOptions *) 0 ;
37474 :
37475 : (void)jenv;
37476 : (void)jcls;
37477 0 : arg1 = *(GDALTileIndexOptions **)&jarg1;
37478 0 : delete_GDALTileIndexOptions(arg1);
37479 0 : }
37480 :
37481 :
37482 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_TileIndex_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2, jlong jarg3, jobject jarg3_, jobject jarg4) {
37483 0 : jlong jresult = 0 ;
37484 0 : char *arg1 = (char *) 0 ;
37485 0 : char **arg2 = (char **) 0 ;
37486 0 : GDALTileIndexOptions *arg3 = (GDALTileIndexOptions *) 0 ;
37487 : GDALProgressFunc arg4 ;
37488 0 : void *arg5 = (void *) 0 ;
37489 0 : GDALDatasetShadow *result = 0 ;
37490 :
37491 : (void)jenv;
37492 : (void)jcls;
37493 : JavaProgressData sProgressInfo;
37494 0 : sProgressInfo.jenv = jenv;
37495 0 : sProgressInfo.pJavaCallback = NULL;
37496 : (void)jarg3_;
37497 0 : arg1 = 0;
37498 0 : if (jarg1) {
37499 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37500 0 : if (!arg1) return 0;
37501 : }
37502 : {
37503 : /* %typemap(in) char **options */
37504 0 : arg2 = NULL;
37505 0 : if(jarg2 != 0) {
37506 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37507 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37508 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37509 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37510 : "()Ljava/util/Enumeration;");
37511 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37512 : "hasMoreElements", "()Z");
37513 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37514 : "nextElement", "()Ljava/lang/Object;");
37515 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37516 0 : hasMoreElements == NULL || getNextElement == NULL) {
37517 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37518 0 : return 0;
37519 : }
37520 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
37521 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37522 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37523 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37524 : {
37525 0 : CSLDestroy(arg2);
37526 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37527 0 : return 0;
37528 : }
37529 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37530 0 : arg2 = CSLAddString(arg2, valptr);
37531 0 : jenv->ReleaseStringUTFChars(value, valptr);
37532 : }
37533 : }
37534 : }
37535 0 : arg3 = *(GDALTileIndexOptions **)&jarg3;
37536 : {
37537 0 : if ( jarg4 != 0 ) {
37538 0 : sProgressInfo.pJavaCallback = jarg4;
37539 0 : arg4 = JavaProgressProxy;
37540 0 : arg5 = &sProgressInfo;
37541 : }
37542 : else
37543 : {
37544 0 : arg4 = NULL;
37545 0 : arg5 = NULL;
37546 : }
37547 : }
37548 : {
37549 0 : if (!arg1) {
37550 : {
37551 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37552 : };
37553 : }
37554 : }
37555 0 : result = (GDALDatasetShadow *)wrapper_TileIndex_names((char const *)arg1,arg2,arg3,arg4,arg5);
37556 0 : *(GDALDatasetShadow **)&jresult = result;
37557 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37558 : {
37559 : /* %typemap(freearg) char **options */
37560 0 : CSLDestroy( arg2 );
37561 : }
37562 0 : return jresult;
37563 : }
37564 :
37565 :
37566 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_TileIndex_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jobject jarg2, jlong jarg3, jobject jarg3_) {
37567 0 : jlong jresult = 0 ;
37568 0 : char *arg1 = (char *) 0 ;
37569 0 : char **arg2 = (char **) 0 ;
37570 0 : GDALTileIndexOptions *arg3 = (GDALTileIndexOptions *) 0 ;
37571 0 : GDALDatasetShadow *result = 0 ;
37572 :
37573 : (void)jenv;
37574 : (void)jcls;
37575 : (void)jarg3_;
37576 0 : arg1 = 0;
37577 0 : if (jarg1) {
37578 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37579 0 : if (!arg1) return 0;
37580 : }
37581 : {
37582 : /* %typemap(in) char **options */
37583 0 : arg2 = NULL;
37584 0 : if(jarg2 != 0) {
37585 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37586 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37587 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37588 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37589 : "()Ljava/util/Enumeration;");
37590 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37591 : "hasMoreElements", "()Z");
37592 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37593 : "nextElement", "()Ljava/lang/Object;");
37594 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37595 0 : hasMoreElements == NULL || getNextElement == NULL) {
37596 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37597 0 : return 0;
37598 : }
37599 0 : for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
37600 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37601 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37602 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37603 : {
37604 0 : CSLDestroy(arg2);
37605 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37606 0 : return 0;
37607 : }
37608 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37609 0 : arg2 = CSLAddString(arg2, valptr);
37610 0 : jenv->ReleaseStringUTFChars(value, valptr);
37611 : }
37612 : }
37613 : }
37614 0 : arg3 = *(GDALTileIndexOptions **)&jarg3;
37615 : {
37616 0 : if (!arg1) {
37617 : {
37618 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37619 : };
37620 : }
37621 : }
37622 0 : result = (GDALDatasetShadow *)wrapper_TileIndex_names((char const *)arg1,arg2,arg3);
37623 0 : *(GDALDatasetShadow **)&jresult = result;
37624 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37625 : {
37626 : /* %typemap(freearg) char **options */
37627 0 : CSLDestroy( arg2 );
37628 : }
37629 0 : return jresult;
37630 : }
37631 :
37632 :
37633 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_new_1MultiDimTranslateOptions(JNIEnv *jenv, jclass jcls, jobject jarg1) {
37634 0 : jlong jresult = 0 ;
37635 0 : char **arg1 = (char **) 0 ;
37636 0 : GDALMultiDimTranslateOptions *result = 0 ;
37637 :
37638 : (void)jenv;
37639 : (void)jcls;
37640 : {
37641 : /* %typemap(in) char **options */
37642 0 : arg1 = NULL;
37643 0 : if(jarg1 != 0) {
37644 0 : const jclass vector = jenv->FindClass("java/util/Vector");
37645 0 : const jclass enumeration = jenv->FindClass("java/util/Enumeration");
37646 0 : const jclass stringClass = jenv->FindClass("java/lang/String");
37647 0 : const jmethodID elements = jenv->GetMethodID(vector, "elements",
37648 : "()Ljava/util/Enumeration;");
37649 0 : const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
37650 : "hasMoreElements", "()Z");
37651 0 : const jmethodID getNextElement = jenv->GetMethodID(enumeration,
37652 : "nextElement", "()Ljava/lang/Object;");
37653 0 : if(vector == NULL || enumeration == NULL || elements == NULL ||
37654 0 : hasMoreElements == NULL || getNextElement == NULL) {
37655 0 : fprintf(stderr, "Could not load (options **) jni types.\n");
37656 0 : return 0;
37657 : }
37658 0 : for (jobject keys = jenv->CallObjectMethod(jarg1, elements);
37659 0 : jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
37660 0 : jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
37661 0 : if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
37662 : {
37663 0 : CSLDestroy(arg1);
37664 0 : SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
37665 0 : return 0;
37666 : }
37667 0 : const char *valptr = jenv->GetStringUTFChars(value, 0);
37668 0 : arg1 = CSLAddString(arg1, valptr);
37669 0 : jenv->ReleaseStringUTFChars(value, valptr);
37670 : }
37671 : }
37672 : }
37673 0 : result = (GDALMultiDimTranslateOptions *)new_GDALMultiDimTranslateOptions(arg1);
37674 0 : *(GDALMultiDimTranslateOptions **)&jresult = result;
37675 : {
37676 : /* %typemap(freearg) char **options */
37677 0 : CSLDestroy( arg1 );
37678 : }
37679 0 : return jresult;
37680 : }
37681 :
37682 :
37683 0 : SWIGEXPORT void JNICALL Java_org_gdal_gdal_gdalJNI_delete_1MultiDimTranslateOptions(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37684 0 : GDALMultiDimTranslateOptions *arg1 = (GDALMultiDimTranslateOptions *) 0 ;
37685 :
37686 : (void)jenv;
37687 : (void)jcls;
37688 0 : arg1 = *(GDALMultiDimTranslateOptions **)&jarg1;
37689 0 : delete_GDALMultiDimTranslateOptions(arg1);
37690 0 : }
37691 :
37692 :
37693 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MultiDimTranslate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_, jobject jarg5) {
37694 0 : jlong jresult = 0 ;
37695 0 : char *arg1 = (char *) 0 ;
37696 : int arg2 ;
37697 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
37698 0 : GDALMultiDimTranslateOptions *arg4 = (GDALMultiDimTranslateOptions *) 0 ;
37699 : GDALProgressFunc arg5 ;
37700 0 : void *arg6 = (void *) 0 ;
37701 0 : GDALDatasetShadow *result = 0 ;
37702 :
37703 : (void)jenv;
37704 : (void)jcls;
37705 : JavaProgressData sProgressInfo;
37706 0 : sProgressInfo.jenv = jenv;
37707 0 : sProgressInfo.pJavaCallback = NULL;
37708 : (void)jarg4_;
37709 0 : arg1 = 0;
37710 0 : if (jarg1) {
37711 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37712 0 : if (!arg1) return 0;
37713 : }
37714 : {
37715 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
37716 : /* check if is List */
37717 0 : if (jarg2)
37718 : {
37719 0 : arg2 = jenv->GetArrayLength(jarg2);
37720 0 : if (arg2 == 0)
37721 0 : arg3 = NULL;
37722 : else
37723 : {
37724 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
37725 : int i;
37726 0 : for (i=0; i<arg2; i++) {
37727 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
37728 0 : if (obj == NULL)
37729 : {
37730 0 : free (arg3 );
37731 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
37732 0 : return 0;
37733 : }
37734 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
37735 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
37736 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
37737 : }
37738 : }
37739 : }
37740 : else
37741 : {
37742 0 : arg2 = 0;
37743 0 : arg3 = NULL;
37744 : }
37745 : }
37746 0 : arg4 = *(GDALMultiDimTranslateOptions **)&jarg4;
37747 : {
37748 0 : if ( jarg5 != 0 ) {
37749 0 : sProgressInfo.pJavaCallback = jarg5;
37750 0 : arg5 = JavaProgressProxy;
37751 0 : arg6 = &sProgressInfo;
37752 : }
37753 : else
37754 : {
37755 0 : arg5 = NULL;
37756 0 : arg6 = NULL;
37757 : }
37758 : }
37759 : {
37760 0 : if (!arg1) {
37761 : {
37762 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37763 : };
37764 : }
37765 : }
37766 0 : result = (GDALDatasetShadow *)wrapper_GDALMultiDimTranslateDestName((char const *)arg1,arg2,arg3,arg4,arg5,arg6);
37767 0 : *(GDALDatasetShadow **)&jresult = result;
37768 : {
37769 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
37770 : }
37771 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37772 : {
37773 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
37774 0 : if (arg3) {
37775 0 : free((void*) arg3);
37776 : }
37777 : }
37778 0 : return jresult;
37779 : }
37780 :
37781 :
37782 0 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_MultiDimTranslate_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jlong jarg4, jobject jarg4_) {
37783 0 : jlong jresult = 0 ;
37784 0 : char *arg1 = (char *) 0 ;
37785 : int arg2 ;
37786 0 : GDALDatasetShadow **arg3 = (GDALDatasetShadow **) 0 ;
37787 0 : GDALMultiDimTranslateOptions *arg4 = (GDALMultiDimTranslateOptions *) 0 ;
37788 0 : GDALDatasetShadow *result = 0 ;
37789 :
37790 : (void)jenv;
37791 : (void)jcls;
37792 : (void)jarg4_;
37793 0 : arg1 = 0;
37794 0 : if (jarg1) {
37795 0 : arg1 = (char *)jenv->GetStringUTFChars(jarg1, 0);
37796 0 : if (!arg1) return 0;
37797 : }
37798 : {
37799 : /* %typemap(in) (int object_list_count, GDALDatasetShadow **poObjects) */
37800 : /* check if is List */
37801 0 : if (jarg2)
37802 : {
37803 0 : arg2 = jenv->GetArrayLength(jarg2);
37804 0 : if (arg2 == 0)
37805 0 : arg3 = NULL;
37806 : else
37807 : {
37808 0 : arg3 = (GDALDatasetShadow**) malloc(sizeof(GDALDatasetShadow*) * arg2);
37809 : int i;
37810 0 : for (i=0; i<arg2; i++) {
37811 0 : jobject obj = (jobject)jenv->GetObjectArrayElement(jarg2, i);
37812 0 : if (obj == NULL)
37813 : {
37814 0 : free (arg3 );
37815 0 : SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null object in array");
37816 0 : return 0;
37817 : }
37818 0 : const jclass klass = jenv->FindClass("org/gdal/gdal/Dataset");
37819 0 : const jmethodID getCPtr = jenv->GetStaticMethodID(klass, "getCPtr", "(Lorg/gdal/gdal/Dataset;)J");
37820 0 : arg3[i] = (GDALDatasetShadow*) jenv->CallStaticLongMethod(klass, getCPtr, obj);
37821 : }
37822 : }
37823 : }
37824 : else
37825 : {
37826 0 : arg2 = 0;
37827 0 : arg3 = NULL;
37828 : }
37829 : }
37830 0 : arg4 = *(GDALMultiDimTranslateOptions **)&jarg4;
37831 : {
37832 0 : if (!arg1) {
37833 : {
37834 0 : SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0;
37835 : };
37836 : }
37837 : }
37838 0 : result = (GDALDatasetShadow *)wrapper_GDALMultiDimTranslateDestName((char const *)arg1,arg2,arg3,arg4);
37839 0 : *(GDALDatasetShadow **)&jresult = result;
37840 : {
37841 : /* %typemap(argout) (int object_list_count, GDALDatasetShadow **poObjects) */
37842 : }
37843 0 : if (arg1) jenv->ReleaseStringUTFChars(jarg1, (const char *)arg1);
37844 : {
37845 : /* %typemap(freearg) (int object_list_count, GDALDatasetShadow **poObjects) */
37846 0 : if (arg3) {
37847 0 : free((void*) arg3);
37848 : }
37849 : }
37850 0 : return jresult;
37851 : }
37852 :
37853 :
37854 2 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_TermProgressCallback_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37855 2 : jlong baseptr = 0;
37856 : (void)jenv;
37857 : (void)jcls;
37858 2 : *(ProgressCallback **)&baseptr = *(TermProgressCallback **)&jarg1;
37859 2 : return baseptr;
37860 : }
37861 :
37862 9 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Driver_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37863 9 : jlong baseptr = 0;
37864 : (void)jenv;
37865 : (void)jcls;
37866 9 : *(GDALMajorObjectShadow **)&baseptr = *(GDALDriverShadow **)&jarg1;
37867 9 : return baseptr;
37868 : }
37869 :
37870 19 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Dataset_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37871 19 : jlong baseptr = 0;
37872 : (void)jenv;
37873 : (void)jcls;
37874 19 : *(GDALMajorObjectShadow **)&baseptr = *(GDALDatasetShadow **)&jarg1;
37875 19 : return baseptr;
37876 : }
37877 :
37878 15 : SWIGEXPORT jlong JNICALL Java_org_gdal_gdal_gdalJNI_Band_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
37879 15 : jlong baseptr = 0;
37880 : (void)jenv;
37881 : (void)jcls;
37882 15 : *(GDALMajorObjectShadow **)&baseptr = *(GDALRasterBandShadow **)&jarg1;
37883 15 : return baseptr;
37884 : }
37885 :
37886 : #ifdef __cplusplus
37887 : }
37888 : #endif
37889 :
|
