/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */


#ifndef SWIGJAVA
#define SWIGJAVA
#endif



#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif


/* Fix for jlong on some versions of gcc on Windows */
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
  typedef long long __int64;
#endif

/* Fix for jlong on 64-bit x86 Solaris */
#if defined(__x86_64)
# ifdef _LP64
#   undef _LP64
# endif
#endif

#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1,
  SWIG_JavaIOException,
  SWIG_JavaRuntimeException,
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaDirectorPureVirtual,
  SWIG_JavaUnknownError,
  SWIG_JavaIllegalStateException,
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;


static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
  };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  jenv->ExceptionClear();
  excep = jenv->FindClass(except_ptr->java_exception);
  if (excep)
    jenv->ThrowNew(excep, msg);
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13




SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
  SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
  switch(code) {
  case SWIG_MemoryError:
    exception_code = SWIG_JavaOutOfMemoryError;
    break;
  case SWIG_IOError:
    exception_code = SWIG_JavaIOException;
    break;
  case SWIG_SystemError:
  case SWIG_RuntimeError:
    exception_code = SWIG_JavaRuntimeException;
    break;
  case SWIG_OverflowError:
  case SWIG_IndexError:
    exception_code = SWIG_JavaIndexOutOfBoundsException;
    break;
  case SWIG_DivisionByZero:
    exception_code = SWIG_JavaArithmeticException;
    break;
  case SWIG_SyntaxError:
  case SWIG_ValueError:
  case SWIG_TypeError:
    exception_code = SWIG_JavaIllegalArgumentException;
    break;
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_JavaUnknownError;
    break;
  }
  SWIG_JavaThrowException(jenv, exception_code, msg);
}


#include <typeinfo>
#include <stdexcept>


#include <iostream>
using namespace std;

#define CPL_SUPRESS_CPLUSPLUS

#include "gdal.h"
#include "ogr_api.h"
#include "ogr_core.h"
#include "cpl_port.h"
#include "cpl_string.h"
#include "ogr_srs_api.h"
#include "gnm_api.h"

typedef void GDALMajorObjectShadow;
typedef void GNMNetworkShadow;
typedef void GNMGenericNetworkShadow;

#ifdef DEBUG
typedef struct OGRSpatialReferenceHS OSRSpatialReferenceShadow;
typedef struct OGRDriverHS OGRDriverShadow;
typedef struct OGRDataSourceHS OGRDataSourceShadow;
typedef struct OGRLayerHS OGRLayerShadow;
typedef struct OGRFeatureHS OGRFeatureShadow;
typedef struct OGRFeatureDefnHS OGRFeatureDefnShadow;
typedef struct OGRGeometryHS OGRGeometryShadow;
typedef struct OGRCoordinateTransformationHS OSRCoordinateTransformationShadow;
typedef struct OGRCoordinateTransformationHS OGRCoordinateTransformationShadow;
typedef struct OGRFieldDefnHS OGRFieldDefnShadow;
#else
typedef void OSRSpatialReferenceShadow;
typedef void OGRDriverShadow;
typedef void OGRDataSourceShadow;
typedef void OGRLayerShadow;
typedef void OGRFeatureShadow;
typedef void OGRFeatureDefnShadow;
typedef void OGRGeometryShadow;
typedef void OSRCoordinateTransformationShadow;
typedef void OGRFieldDefnShadow;
#endif
typedef struct OGRStyleTableHS OGRStyleTableShadow;
typedef struct OGRGeomFieldDefnHS OGRGeomFieldDefnShadow;


static int bUseExceptions=1;

static void CPL_STDCALL
VeryQuietErrorHandler(CPLErr eclass, int code, const char *msg )
{
  /* If the error class is CE_Fatal, we want to have a message issued
     because the CPL support code does an abort() before any exception
     can be generated */
  if (eclass == CE_Fatal ) {
    CPLDefaultErrorHandler(eclass, code, msg );
  }
}


static void UseExceptions() {
  bUseExceptions = 1;
  CPLSetErrorHandler( (CPLErrorHandler) VeryQuietErrorHandler );
}

static void DontUseExceptions() {
  bUseExceptions = 0;
  CPLSetErrorHandler( CPLDefaultErrorHandler );
}

static bool GetUseExceptions() {
  return bUseExceptions == 1;
}


typedef struct {
    JNIEnv *jenv;
    jobject pJavaCallback;
} JavaProgressData;


class ProgressCallback
{
public:
        virtual ~ProgressCallback() {  }
        virtual int run(double dfComplete, const char* pszMessage)
        {
            return 1;
        }
};

class TermProgressCallback : public ProgressCallback
{
public:
    TermProgressCallback()
    {
    }

    virtual int run(double dfComplete, const char* pszMessage)
    {
        return GDALTermProgress(dfComplete, pszMessage, NULL);
    }
};


/************************************************************************/
/*                        JavaProgressProxy()                           */
/************************************************************************/

static int CPL_STDCALL
JavaProgressProxy( double dfComplete, const char *pszMessage, void *pData )
{
    JavaProgressData* psProgressInfo = (JavaProgressData*)pData;
    JNIEnv *jenv = psProgressInfo->jenv;
    int ret;
    const jclass progressCallbackClass = jenv->FindClass("org/gdal/gdal/ProgressCallback");
    const jmethodID runMethod = jenv->GetMethodID(progressCallbackClass, "run", "(DLjava/lang/String;)I");
    jstring temp_string = jenv->NewStringUTF(pszMessage);
    ret = jenv->CallIntMethod(psProgressInfo->pJavaCallback, runMethod, dfComplete, temp_string);
    jenv->DeleteLocalRef(temp_string);
    return ret;
}


#if defined(SWIG_NOINCLUDE) || defined(SWIG_NOARRAYS)


static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input);
static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input);
static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz);


static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input);
static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input);
static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz);


static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input);
static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input);
static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz);


static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input);
static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input);
static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz);


static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input);
static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input);
static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz);


static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input);
static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input);
static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz);


static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input);
static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input);
static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz);


static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input);
static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input);
static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz);


static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input);
static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input);
static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz);


static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input);
static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input);
static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz);


static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input);
static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input);
static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz);


static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input);
static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input);
static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz);


#else


/* bool[] support */
static int SWIG_JavaArrayInBool (JNIEnv *jenv, jboolean **jarr, bool **carr, jbooleanArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetBooleanArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new bool[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = ((*jarr)[i] != 0);
  return 1;
}

static void SWIG_JavaArrayArgoutBool (JNIEnv *jenv, jboolean *jarr, bool *carr, jbooleanArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jboolean)carr[i];
  jenv->ReleaseBooleanArrayElements(input, jarr, 0);
}

static jbooleanArray SWIG_JavaArrayOutBool (JNIEnv *jenv, bool *result, jsize sz) {
  jboolean *arr;
  int i;
  jbooleanArray jresult = jenv->NewBooleanArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetBooleanArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jboolean)result[i];
  jenv->ReleaseBooleanArrayElements(jresult, arr, 0);
  return jresult;
}


/* signed char[] support */
static int SWIG_JavaArrayInSchar (JNIEnv *jenv, jbyte **jarr, signed char **carr, jbyteArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetByteArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new signed char[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (signed char)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutSchar (JNIEnv *jenv, jbyte *jarr, signed char *carr, jbyteArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jbyte)carr[i];
  jenv->ReleaseByteArrayElements(input, jarr, 0);
}

static jbyteArray SWIG_JavaArrayOutSchar (JNIEnv *jenv, signed char *result, jsize sz) {
  jbyte *arr;
  int i;
  jbyteArray jresult = jenv->NewByteArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetByteArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jbyte)result[i];
  jenv->ReleaseByteArrayElements(jresult, arr, 0);
  return jresult;
}


/* unsigned char[] support */
static int SWIG_JavaArrayInUchar (JNIEnv *jenv, jshort **jarr, unsigned char **carr, jshortArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetShortArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new unsigned char[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned char)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutUchar (JNIEnv *jenv, jshort *jarr, unsigned char *carr, jshortArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jshort)carr[i];
  jenv->ReleaseShortArrayElements(input, jarr, 0);
}

static jshortArray SWIG_JavaArrayOutUchar (JNIEnv *jenv, unsigned char *result, jsize sz) {
  jshort *arr;
  int i;
  jshortArray jresult = jenv->NewShortArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetShortArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jshort)result[i];
  jenv->ReleaseShortArrayElements(jresult, arr, 0);
  return jresult;
}


/* short[] support */
static int SWIG_JavaArrayInShort (JNIEnv *jenv, jshort **jarr, short **carr, jshortArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetShortArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new short[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (short)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutShort (JNIEnv *jenv, jshort *jarr, short *carr, jshortArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jshort)carr[i];
  jenv->ReleaseShortArrayElements(input, jarr, 0);
}

static jshortArray SWIG_JavaArrayOutShort (JNIEnv *jenv, short *result, jsize sz) {
  jshort *arr;
  int i;
  jshortArray jresult = jenv->NewShortArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetShortArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jshort)result[i];
  jenv->ReleaseShortArrayElements(jresult, arr, 0);
  return jresult;
}


/* unsigned short[] support */
static int SWIG_JavaArrayInUshort (JNIEnv *jenv, jint **jarr, unsigned short **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetIntArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new unsigned short[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned short)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutUshort (JNIEnv *jenv, jint *jarr, unsigned short *carr, jintArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  jenv->ReleaseIntArrayElements(input, jarr, 0);
}

static jintArray SWIG_JavaArrayOutUshort (JNIEnv *jenv, unsigned short *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = jenv->NewIntArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetIntArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  jenv->ReleaseIntArrayElements(jresult, arr, 0);
  return jresult;
}


/* int[] support */
static int SWIG_JavaArrayInInt (JNIEnv *jenv, jint **jarr, int **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetIntArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new int[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (int)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutInt (JNIEnv *jenv, jint *jarr, int *carr, jintArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  jenv->ReleaseIntArrayElements(input, jarr, 0);
}

static jintArray SWIG_JavaArrayOutInt (JNIEnv *jenv, int *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = jenv->NewIntArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetIntArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  jenv->ReleaseIntArrayElements(jresult, arr, 0);
  return jresult;
}


/* unsigned int[] support */
static int SWIG_JavaArrayInUint (JNIEnv *jenv, jlong **jarr, unsigned int **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetLongArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new unsigned int[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned int)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutUint (JNIEnv *jenv, jlong *jarr, unsigned int *carr, jlongArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  jenv->ReleaseLongArrayElements(input, jarr, 0);
}

static jlongArray SWIG_JavaArrayOutUint (JNIEnv *jenv, unsigned int *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = jenv->NewLongArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetLongArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  jenv->ReleaseLongArrayElements(jresult, arr, 0);
  return jresult;
}


/* long[] support */
static int SWIG_JavaArrayInLong (JNIEnv *jenv, jint **jarr, long **carr, jintArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetIntArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new long[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (long)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutLong (JNIEnv *jenv, jint *jarr, long *carr, jintArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jint)carr[i];
  jenv->ReleaseIntArrayElements(input, jarr, 0);
}

static jintArray SWIG_JavaArrayOutLong (JNIEnv *jenv, long *result, jsize sz) {
  jint *arr;
  int i;
  jintArray jresult = jenv->NewIntArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetIntArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jint)result[i];
  jenv->ReleaseIntArrayElements(jresult, arr, 0);
  return jresult;
}


/* unsigned long[] support */
static int SWIG_JavaArrayInUlong (JNIEnv *jenv, jlong **jarr, unsigned long **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetLongArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new unsigned long[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (unsigned long)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutUlong (JNIEnv *jenv, jlong *jarr, unsigned long *carr, jlongArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  jenv->ReleaseLongArrayElements(input, jarr, 0);
}

static jlongArray SWIG_JavaArrayOutUlong (JNIEnv *jenv, unsigned long *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = jenv->NewLongArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetLongArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  jenv->ReleaseLongArrayElements(jresult, arr, 0);
  return jresult;
}


/* jlong[] support */
static int SWIG_JavaArrayInLonglong (JNIEnv *jenv, jlong **jarr, jlong **carr, jlongArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetLongArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new jlong[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (jlong)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutLonglong (JNIEnv *jenv, jlong *jarr, jlong *carr, jlongArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jlong)carr[i];
  jenv->ReleaseLongArrayElements(input, jarr, 0);
}

static jlongArray SWIG_JavaArrayOutLonglong (JNIEnv *jenv, jlong *result, jsize sz) {
  jlong *arr;
  int i;
  jlongArray jresult = jenv->NewLongArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetLongArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jlong)result[i];
  jenv->ReleaseLongArrayElements(jresult, arr, 0);
  return jresult;
}


/* float[] support */
static int SWIG_JavaArrayInFloat (JNIEnv *jenv, jfloat **jarr, float **carr, jfloatArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetFloatArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new float[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (float)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutFloat (JNIEnv *jenv, jfloat *jarr, float *carr, jfloatArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jfloat)carr[i];
  jenv->ReleaseFloatArrayElements(input, jarr, 0);
}

static jfloatArray SWIG_JavaArrayOutFloat (JNIEnv *jenv, float *result, jsize sz) {
  jfloat *arr;
  int i;
  jfloatArray jresult = jenv->NewFloatArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetFloatArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jfloat)result[i];
  jenv->ReleaseFloatArrayElements(jresult, arr, 0);
  return jresult;
}


/* double[] support */
static int SWIG_JavaArrayInDouble (JNIEnv *jenv, jdouble **jarr, double **carr, jdoubleArray input) {
  int i;
  jsize sz;
  if (!input) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null array");
    return 0;
  }
  sz = jenv->GetArrayLength(input);
  *jarr = jenv->GetDoubleArrayElements(input, 0);
  if (!*jarr)
    return 0; 
  *carr = new double[sz]; 
  if (!*carr) {
    SWIG_JavaThrowException(jenv, SWIG_JavaOutOfMemoryError, "array memory allocation failed");
    return 0;
  }
  for (i=0; i<sz; i++)
    (*carr)[i] = (double)(*jarr)[i];
  return 1;
}

static void SWIG_JavaArrayArgoutDouble (JNIEnv *jenv, jdouble *jarr, double *carr, jdoubleArray input) {
  int i;
  jsize sz = jenv->GetArrayLength(input);
  for (i=0; i<sz; i++)
    jarr[i] = (jdouble)carr[i];
  jenv->ReleaseDoubleArrayElements(input, jarr, 0);
}

static jdoubleArray SWIG_JavaArrayOutDouble (JNIEnv *jenv, double *result, jsize sz) {
  jdouble *arr;
  int i;
  jdoubleArray jresult = jenv->NewDoubleArray(sz);
  if (!jresult)
    return NULL;
  arr = jenv->GetDoubleArrayElements(jresult, 0);
  if (!arr)
    return NULL;
  for (i=0; i<sz; i++)
    arr[i] = (jdouble)result[i];
  jenv->ReleaseDoubleArrayElements(jresult, arr, 0);
  return jresult;
}


#endif

SWIGINTERN void delete_GNMNetworkShadow(GNMNetworkShadow *self){
            if ( GDALDereferenceDataset( self ) <= 0 ) {
              GDALClose(self);
            }
        }
SWIGINTERN int GNMNetworkShadow_GetVersion(GNMNetworkShadow *self){
            return GNMGetVersion(self);
        }
SWIGINTERN char const *GNMNetworkShadow_GetName(GNMNetworkShadow *self){
            return GNMGetName(self);
        }
SWIGINTERN OGRFeatureShadow *GNMNetworkShadow_GetFeatureByGlobalFID(GNMNetworkShadow *self,GIntBig GFID){
            return GNMGetFeatureByGlobalFID(self, GFID);
        }
SWIGINTERN OGRLayerShadow *GNMNetworkShadow_GetPath__SWIG_0(GNMNetworkShadow *self,GIntBig nStartFID,GIntBig nEndFID,GNMGraphAlgorithmType eAlgorithm,char **options=0){
            return GNMGetPath(self, nStartFID, nEndFID, eAlgorithm, options);
        }
SWIGINTERN CPLErr GNMNetworkShadow_DisconnectAll(GNMNetworkShadow *self){
            return GNMDisconnectAll( self );
        }
SWIGINTERN char const *GNMNetworkShadow_GetProjection(GNMNetworkShadow *self){
            return GDALGetProjectionRef( self );
        }
SWIGINTERN char const *GNMNetworkShadow_GetProjectionRef(GNMNetworkShadow *self){
            return GDALGetProjectionRef( self );
        }
SWIGINTERN char **GNMNetworkShadow_GetFileList(GNMNetworkShadow *self){
            return GDALGetFileList( self );
        }
SWIGINTERN OGRLayerShadow *GNMNetworkShadow_CreateLayer__SWIG_0(GNMNetworkShadow *self,char const *name,OSRSpatialReferenceShadow *srs=NULL,OGRwkbGeometryType geom_type=wkbUnknown,char **options=0){
            OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCreateLayer( self,
                                      name,
                                      srs,
                                      geom_type,
                                      options);
            return layer;
        }
SWIGINTERN OGRLayerShadow *GNMNetworkShadow_CopyLayer__SWIG_0(GNMNetworkShadow *self,OGRLayerShadow *src_layer,char const *new_name,char **options=0){
            OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetCopyLayer( self,
                                                      src_layer,
                                                      new_name,
                                                      options);
            return layer;
        }
SWIGINTERN OGRErr GNMNetworkShadow_DeleteLayer(GNMNetworkShadow *self,int index){
            return GDALDatasetDeleteLayer(self, index);
        }


#include "ogr_core.h"
static char const *
OGRErrMessages( int rc ) {
  switch( rc ) {
  case OGRERR_NONE:
    return "OGR Error: None";
  case OGRERR_NOT_ENOUGH_DATA:
    return "OGR Error: Not enough data to deserialize";
  case OGRERR_NOT_ENOUGH_MEMORY:
    return "OGR Error: Not enough memory";
  case OGRERR_UNSUPPORTED_GEOMETRY_TYPE:
    return "OGR Error: Unsupported geometry type";
  case OGRERR_UNSUPPORTED_OPERATION:
    return "OGR Error: Unsupported operation";
  case OGRERR_CORRUPT_DATA:
    return "OGR Error: Corrupt data";
  case OGRERR_FAILURE:
    return "OGR Error: General Error";
  case OGRERR_UNSUPPORTED_SRS:
    return "OGR Error: Unsupported SRS";
  case OGRERR_INVALID_HANDLE:
    return "OGR Error: Invalid handle";
  case OGRERR_NON_EXISTING_FEATURE:
    return "OGR Error: Non existing feature";
  default:
    return "OGR Error: Unknown";
  }
}

SWIGINTERN int GNMNetworkShadow_GetLayerCount(GNMNetworkShadow *self){
            return GDALDatasetGetLayerCount(self);
        }
SWIGINTERN OGRLayerShadow *GNMNetworkShadow_GetLayerByIndex(GNMNetworkShadow *self,int index){
        


        OGRLayerShadow* layer = (OGRLayerShadow*) GDALDatasetGetLayer(self,
                                                                      index);
            return layer;
        }
SWIGINTERN OGRLayerShadow *GNMNetworkShadow_GetLayerByName(GNMNetworkShadow *self,char const *layer_name){
            OGRLayerShadow* layer =
                  (OGRLayerShadow*) GDALDatasetGetLayerByName(self, layer_name);
            return layer;
        }
SWIGINTERN bool GNMNetworkShadow_TestCapability(GNMNetworkShadow *self,char const *cap){
            return (GDALDatasetTestCapability(self, cap) > 0);
        }
SWIGINTERN OGRErr GNMNetworkShadow_StartTransaction__SWIG_0(GNMNetworkShadow *self,int force=FALSE){
            return GDALDatasetStartTransaction(self, force);
        }
SWIGINTERN OGRErr GNMNetworkShadow_CommitTransaction(GNMNetworkShadow *self){
            return GDALDatasetCommitTransaction(self);
        }
SWIGINTERN OGRErr GNMNetworkShadow_RollbackTransaction(GNMNetworkShadow *self){
            return GDALDatasetRollbackTransaction(self);
        }
SWIGINTERN void delete_GNMGenericNetworkShadow(GNMGenericNetworkShadow *self){
            if ( GDALDereferenceDataset( self ) <= 0 ) {
              GDALClose(self);
            }
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_ConnectFeatures(GNMGenericNetworkShadow *self,GIntBig nSrcFID,GIntBig nTgtFID,GIntBig nConFID,double dfCost,double dfInvCost,GNMDirection eDir){
            return GNMConnectFeatures(self, nSrcFID, nTgtFID,
                                              nConFID, dfCost, dfInvCost, eDir);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_DisconnectFeatures(GNMGenericNetworkShadow *self,GIntBig nSrcFID,GIntBig nTgtFID,GIntBig nConFID){
            return GNMDisconnectFeatures(self, nSrcFID, nTgtFID,
                                                           nConFID);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_DisconnectFeaturesWithId(GNMGenericNetworkShadow *self,GIntBig nFID){
            return GNMDisconnectFeaturesWithId(self, nFID);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_ReconnectFeatures(GNMGenericNetworkShadow *self,GIntBig nSrcFID,GIntBig nTgtFID,GIntBig nConFID,double dfCost,double dfInvCost,GNMDirection eDir){
            return GNMReconnectFeatures(self, nSrcFID, nTgtFID, nConFID, dfCost, dfInvCost, eDir);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_CreateRule(GNMGenericNetworkShadow *self,char const *pszRuleStr){
            return GNMCreateRule(self, pszRuleStr);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_DeleteAllRules(GNMGenericNetworkShadow *self){
            return GNMDeleteAllRules(self);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_DeleteRule(GNMGenericNetworkShadow *self,char const *pszRuleStr){
            return GNMDeleteRule(self, pszRuleStr);
        }
SWIGINTERN char **GNMGenericNetworkShadow_GetRules(GNMGenericNetworkShadow *self){
            return GNMGetRules(self);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_ConnectPointsByLines(GNMGenericNetworkShadow *self,char **papszLayerList,double dfTolerance,double dfCost,double dfInvCost,GNMDirection eDir){
            return GNMConnectPointsByLines(self, papszLayerList, dfTolerance, dfCost, dfInvCost, eDir);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_ChangeBlockState(GNMGenericNetworkShadow *self,GIntBig nFID,bool bIsBlock){
            return GNMChangeBlockState(self, nFID, bIsBlock);
        }
SWIGINTERN CPLErr GNMGenericNetworkShadow_ChangeAllBlockState__SWIG_0(GNMGenericNetworkShadow *self,bool bIsBlock=false){
            return GNMChangeAllBlockState(self, bIsBlock);
        }

#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_UseExceptions(JNIEnv *jenv, jclass jcls) {
  (void)jenv;
  (void)jcls;
  UseExceptions();
}


SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_DontUseExceptions(JNIEnv *jenv, jclass jcls) {
  (void)jenv;
  (void)jcls;
  DontUseExceptions();
}


SWIGEXPORT jboolean JNICALL Java_org_gdal_gnm_gnmJNI_GetUseExceptions(JNIEnv *jenv, jclass jcls) {
  jboolean jresult = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  result = (bool)GetUseExceptions();
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_delete_1ProgressCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  ProgressCallback *arg1 = (ProgressCallback *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(ProgressCallback **)&jarg1; 
  delete arg1;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_ProgressCallback_1run(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jstring jarg3) {
  jint jresult = 0 ;
  ProgressCallback *arg1 = (ProgressCallback *) 0 ;
  double arg2 ;
  char *arg3 = (char *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ProgressCallback **)&jarg1; 
  arg2 = (double)jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  result = (int)(arg1)->run(arg2,(char const *)arg3);
  jresult = (jint)result; 
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_new_1ProgressCallback(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  ProgressCallback *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (ProgressCallback *)new ProgressCallback();
  *(ProgressCallback **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_new_1TermProgressCallback(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  TermProgressCallback *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (TermProgressCallback *)new TermProgressCallback();
  *(TermProgressCallback **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_TermProgressCallback_1run(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jdouble jarg2, jstring jarg3) {
  jint jresult = 0 ;
  TermProgressCallback *arg1 = (TermProgressCallback *) 0 ;
  double arg2 ;
  char *arg3 = (char *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(TermProgressCallback **)&jarg1; 
  arg2 = (double)jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  result = (int)(arg1)->run(arg2,(char const *)arg3);
  jresult = (jint)result; 
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_delete_1TermProgressCallback(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  TermProgressCallback *arg1 = (TermProgressCallback *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(TermProgressCallback **)&jarg1; 
  delete arg1;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GATDijkstraShortestPath_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  GNMGraphAlgorithmType result;
  
  (void)jenv;
  (void)jcls;
  result = (GNMGraphAlgorithmType)GATDijkstraShortestPath;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GATKShortestPath_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  GNMGraphAlgorithmType result;
  
  (void)jenv;
  (void)jcls;
  result = (GNMGraphAlgorithmType)GATKShortestPath;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GATConnectedComponents_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  GNMGraphAlgorithmType result;
  
  (void)jenv;
  (void)jcls;
  result = (GNMGraphAlgorithmType)GATConnectedComponents;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GNM_1EDGE_1DIR_1BOTH_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(0);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GNM_1EDGE_1DIR_1SRCTOTGT_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GNM_1EDGE_1DIR_1TGTTOSRC_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(2);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_delete_1Network(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  delete_GNMNetworkShadow(arg1);
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetVersion(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (int)GNMNetworkShadow_GetVersion(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (char *)GNMNetworkShadow_GetName(arg1);
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetFeatureByGlobalFID(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  GIntBig arg2 ;
  OGRFeatureShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  result = (OGRFeatureShadow *)GNMNetworkShadow_GetFeatureByGlobalFID(arg1,arg2);
  *(OGRFeatureShadow **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetPath_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jint jarg4, jobject jarg5) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  GIntBig arg2 ;
  GIntBig arg3 ;
  GNMGraphAlgorithmType arg4 ;
  char **arg5 = (char **) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  arg4 = (GNMGraphAlgorithmType)jarg4; 
  {
    /* %typemap(in) char **options */
    arg5 = NULL;
    if(jarg5 != 0) {
      const jclass vector = jenv->FindClass("java/util/Vector");
      const jclass enumeration = jenv->FindClass("java/util/Enumeration");
      const jclass stringClass = jenv->FindClass("java/lang/String");
      const jmethodID elements = jenv->GetMethodID(vector, "elements",
        "()Ljava/util/Enumeration;");
      const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
        "hasMoreElements", "()Z");
      const jmethodID getNextElement = jenv->GetMethodID(enumeration,
        "nextElement", "()Ljava/lang/Object;");
      if(vector == NULL || enumeration == NULL || elements == NULL ||
        hasMoreElements == NULL || getNextElement == NULL) {
        fprintf(stderr, "Could not load (options **) jni types.\n");
        return 0;
      }
      for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
        jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
        jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
        if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
        {
          CSLDestroy(arg5);
          SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
          return 0;
        }
        const char *valptr = jenv->GetStringUTFChars(value, 0);
        arg5 = CSLAddString(arg5,  valptr);
        jenv->ReleaseStringUTFChars(value, valptr);
      }
    }
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_GetPath__SWIG_0(arg1,arg2,arg3,arg4,arg5);
  *(OGRLayerShadow **)&jresult = result; 
  {
    /* %typemap(freearg) char **options */
    CSLDestroy( arg5 );
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetPath_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jint jarg4) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  GIntBig arg2 ;
  GIntBig arg3 ;
  GNMGraphAlgorithmType arg4 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  arg4 = (GNMGraphAlgorithmType)jarg4; 
  result = (OGRLayerShadow *)GNMNetworkShadow_GetPath__SWIG_0(arg1,arg2,arg3,arg4);
  *(OGRLayerShadow **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1DisconnectAll(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (CPLErr)GNMNetworkShadow_DisconnectAll(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetProjection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (char *)GNMNetworkShadow_GetProjection(arg1);
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetProjectionRef(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (char *)GNMNetworkShadow_GetProjectionRef(arg1);
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetFileList(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char **result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (char **)GNMNetworkShadow_GetFileList(arg1);
  {
    /* %typemap(out) char **CSL -> vector of strings */
    char **stringarray = result;
    const jclass vector = jenv->FindClass("java/util/Vector");
    const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
    const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
    
    jresult = jenv->NewObject(vector, constructor);
    if ( stringarray != NULL ) {
      while(*stringarray != NULL) {
        /*printf("working on string %s\n", *stringarray);*/
        jstring value = (jstring)jenv->NewStringUTF(*stringarray);
        jenv->CallBooleanMethod(jresult, add, value);
        jenv->DeleteLocalRef(value);
        stringarray++;
      }
    }
    CSLDestroy(result);
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CreateLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4, jobject jarg5) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
  OGRwkbGeometryType arg4 ;
  char **arg5 = (char **) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = *(OSRSpatialReferenceShadow **)&jarg3; 
  arg4 = (OGRwkbGeometryType)jarg4; 
  {
    /* %typemap(in) char **options */
    arg5 = NULL;
    if(jarg5 != 0) {
      const jclass vector = jenv->FindClass("java/util/Vector");
      const jclass enumeration = jenv->FindClass("java/util/Enumeration");
      const jclass stringClass = jenv->FindClass("java/lang/String");
      const jmethodID elements = jenv->GetMethodID(vector, "elements",
        "()Ljava/util/Enumeration;");
      const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
        "hasMoreElements", "()Z");
      const jmethodID getNextElement = jenv->GetMethodID(enumeration,
        "nextElement", "()Ljava/lang/Object;");
      if(vector == NULL || enumeration == NULL || elements == NULL ||
        hasMoreElements == NULL || getNextElement == NULL) {
        fprintf(stderr, "Could not load (options **) jni types.\n");
        return 0;
      }
      for (jobject keys = jenv->CallObjectMethod(jarg5, elements);
        jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
        jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
        if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
        {
          CSLDestroy(arg5);
          SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
          return 0;
        }
        const char *valptr = jenv->GetStringUTFChars(value, 0);
        arg5 = CSLAddString(arg5,  valptr);
        jenv->ReleaseStringUTFChars(value, valptr);
      }
    }
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3,arg4,arg5);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  {
    /* %typemap(freearg) char **options */
    CSLDestroy( arg5 );
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CreateLayer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jint jarg4) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
  OGRwkbGeometryType arg4 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = *(OSRSpatialReferenceShadow **)&jarg3; 
  arg4 = (OGRwkbGeometryType)jarg4; 
  result = (OGRLayerShadow *)GNMNetworkShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3,arg4);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CreateLayer_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  OSRSpatialReferenceShadow *arg3 = (OSRSpatialReferenceShadow *) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = *(OSRSpatialReferenceShadow **)&jarg3; 
  result = (OGRLayerShadow *)GNMNetworkShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2,arg3);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CreateLayer_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_CreateLayer__SWIG_0(arg1,(char const *)arg2);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CopyLayer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jobject jarg4) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
  char *arg3 = (char *) 0 ;
  char **arg4 = (char **) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = *(OGRLayerShadow **)&jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  {
    /* %typemap(in) char **options */
    arg4 = NULL;
    if(jarg4 != 0) {
      const jclass vector = jenv->FindClass("java/util/Vector");
      const jclass enumeration = jenv->FindClass("java/util/Enumeration");
      const jclass stringClass = jenv->FindClass("java/lang/String");
      const jmethodID elements = jenv->GetMethodID(vector, "elements",
        "()Ljava/util/Enumeration;");
      const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
        "hasMoreElements", "()Z");
      const jmethodID getNextElement = jenv->GetMethodID(enumeration,
        "nextElement", "()Ljava/lang/Object;");
      if(vector == NULL || enumeration == NULL || elements == NULL ||
        hasMoreElements == NULL || getNextElement == NULL) {
        fprintf(stderr, "Could not load (options **) jni types.\n");
        return 0;
      }
      for (jobject keys = jenv->CallObjectMethod(jarg4, elements);
        jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
        jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
        if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
        {
          CSLDestroy(arg4);
          SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
          return 0;
        }
        const char *valptr = jenv->GetStringUTFChars(value, 0);
        arg4 = CSLAddString(arg4,  valptr);
        jenv->ReleaseStringUTFChars(value, valptr);
      }
    }
  }
  {
    if (!arg2) {
      {
        SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0; 
      };
    }
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_CopyLayer__SWIG_0(arg1,arg2,(char const *)arg3,arg4);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  {
    /* %typemap(freearg) char **options */
    CSLDestroy( arg4 );
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CopyLayer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  OGRLayerShadow *arg2 = (OGRLayerShadow *) 0 ;
  char *arg3 = (char *) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = *(OGRLayerShadow **)&jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  {
    if (!arg2) {
      {
        SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0; 
      };
    }
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_CopyLayer__SWIG_0(arg1,arg2,(char const *)arg3);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1DeleteLayer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  int arg2 ;
  OGRErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = (int)jarg2; 
  result = (OGRErr)GNMNetworkShadow_DeleteLayer(arg1,arg2);
  {
    /* %typemap(out) OGRErr */
    if (result != 0 && bUseExceptions) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
        OGRErrMessages(result));
      return 0;
    }
    jresult = (jint)result;
  }
  {
    /* %typemap(ret) OGRErr */
    
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetLayerCount(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (int)GNMNetworkShadow_GetLayerCount(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetLayerByIndex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  int arg2 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = (int)jarg2; 
  result = (OGRLayerShadow *)GNMNetworkShadow_GetLayerByIndex(arg1,arg2);
  *(OGRLayerShadow **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1GetLayerByName(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  OGRLayerShadow *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  result = (OGRLayerShadow *)GNMNetworkShadow_GetLayerByName(arg1,(char const *)arg2);
  *(OGRLayerShadow **)&jresult = result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_org_gdal_gnm_gnmJNI_Network_1TestCapability(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    if (!arg2) {
      {
        SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0; 
      };
    }
  }
  result = (bool)GNMNetworkShadow_TestCapability(arg1,(char const *)arg2);
  jresult = (jboolean)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1StartTransaction_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  int arg2 ;
  OGRErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  arg2 = (int)jarg2; 
  result = (OGRErr)GNMNetworkShadow_StartTransaction__SWIG_0(arg1,arg2);
  {
    /* %typemap(out) OGRErr */
    if (result != 0 && bUseExceptions) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
        OGRErrMessages(result));
      return 0;
    }
    jresult = (jint)result;
  }
  {
    /* %typemap(ret) OGRErr */
    
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1StartTransaction_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  OGRErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (OGRErr)GNMNetworkShadow_StartTransaction__SWIG_0(arg1);
  {
    /* %typemap(out) OGRErr */
    if (result != 0 && bUseExceptions) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
        OGRErrMessages(result));
      return 0;
    }
    jresult = (jint)result;
  }
  {
    /* %typemap(ret) OGRErr */
    
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1CommitTransaction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  OGRErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (OGRErr)GNMNetworkShadow_CommitTransaction(arg1);
  {
    /* %typemap(out) OGRErr */
    if (result != 0 && bUseExceptions) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
        OGRErrMessages(result));
      return 0;
    }
    jresult = (jint)result;
  }
  {
    /* %typemap(ret) OGRErr */
    
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_Network_1RollbackTransaction(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMNetworkShadow *arg1 = (GNMNetworkShadow *) 0 ;
  OGRErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMNetworkShadow **)&jarg1; 
  result = (OGRErr)GNMNetworkShadow_RollbackTransaction(arg1);
  {
    /* %typemap(out) OGRErr */
    if (result != 0 && bUseExceptions) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException,
        OGRErrMessages(result));
      return 0;
    }
    jresult = (jint)result;
  }
  {
    /* %typemap(ret) OGRErr */
    
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_org_gdal_gnm_gnmJNI_delete_1GenericNetwork(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  delete_GNMGenericNetworkShadow(arg1);
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ConnectFeatures(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jint jarg7) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  GIntBig arg2 ;
  GIntBig arg3 ;
  GIntBig arg4 ;
  double arg5 ;
  double arg6 ;
  GNMDirection arg7 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  arg4 = jarg4;
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  arg7 = (GNMDirection)jarg7; 
  result = (CPLErr)GNMGenericNetworkShadow_ConnectFeatures(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1DisconnectFeatures(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  GIntBig arg2 ;
  GIntBig arg3 ;
  GIntBig arg4 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  arg4 = jarg4;
  result = (CPLErr)GNMGenericNetworkShadow_DisconnectFeatures(arg1,arg2,arg3,arg4);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1DisconnectFeaturesWithId(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  GIntBig arg2 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  result = (CPLErr)GNMGenericNetworkShadow_DisconnectFeaturesWithId(arg1,arg2);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ReconnectFeatures(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3, jlong jarg4, jdouble jarg5, jdouble jarg6, jint jarg7) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  GIntBig arg2 ;
  GIntBig arg3 ;
  GIntBig arg4 ;
  double arg5 ;
  double arg6 ;
  GNMDirection arg7 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  arg4 = jarg4;
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  arg7 = (GNMDirection)jarg7; 
  result = (CPLErr)GNMGenericNetworkShadow_ReconnectFeatures(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1CreateRule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    if (!arg2) {
      {
        SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0; 
      };
    }
  }
  result = (CPLErr)GNMGenericNetworkShadow_CreateRule(arg1,(char const *)arg2);
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1DeleteAllRules(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  result = (CPLErr)GNMGenericNetworkShadow_DeleteAllRules(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1DeleteRule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  char *arg2 = (char *) 0 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    if (!arg2) {
      {
        SWIG_JavaException(jenv, SWIG_ValueError, "Received a NULL pointer."); return 0; 
      };
    }
  }
  result = (CPLErr)GNMGenericNetworkShadow_DeleteRule(arg1,(char const *)arg2);
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jobject JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1GetRules(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jobject jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  char **result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  result = (char **)GNMGenericNetworkShadow_GetRules(arg1);
  {
    /* %typemap(out) char **CSL -> vector of strings */
    char **stringarray = result;
    const jclass vector = jenv->FindClass("java/util/Vector");
    const jmethodID constructor = jenv->GetMethodID(vector, "<init>", "()V");
    const jmethodID add = jenv->GetMethodID(vector, "add", "(Ljava/lang/Object;)Z");
    
    jresult = jenv->NewObject(vector, constructor);
    if ( stringarray != NULL ) {
      while(*stringarray != NULL) {
        /*printf("working on string %s\n", *stringarray);*/
        jstring value = (jstring)jenv->NewStringUTF(*stringarray);
        jenv->CallBooleanMethod(jresult, add, value);
        jenv->DeleteLocalRef(value);
        stringarray++;
      }
    }
    CSLDestroy(result);
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ConnectPointsByLines(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jobject jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jint jarg6) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  char **arg2 = (char **) 0 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  GNMDirection arg6 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  {
    /* %typemap(in) char **options */
    arg2 = NULL;
    if(jarg2 != 0) {
      const jclass vector = jenv->FindClass("java/util/Vector");
      const jclass enumeration = jenv->FindClass("java/util/Enumeration");
      const jclass stringClass = jenv->FindClass("java/lang/String");
      const jmethodID elements = jenv->GetMethodID(vector, "elements",
        "()Ljava/util/Enumeration;");
      const jmethodID hasMoreElements = jenv->GetMethodID(enumeration,
        "hasMoreElements", "()Z");
      const jmethodID getNextElement = jenv->GetMethodID(enumeration,
        "nextElement", "()Ljava/lang/Object;");
      if(vector == NULL || enumeration == NULL || elements == NULL ||
        hasMoreElements == NULL || getNextElement == NULL) {
        fprintf(stderr, "Could not load (options **) jni types.\n");
        return 0;
      }
      for (jobject keys = jenv->CallObjectMethod(jarg2, elements);
        jenv->CallBooleanMethod(keys, hasMoreElements) == JNI_TRUE;) {
        jstring value = (jstring)jenv->CallObjectMethod(keys, getNextElement);
        if (value == NULL || !jenv->IsInstanceOf(value, stringClass))
        {
          CSLDestroy(arg2);
          SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, "an element in the vector is not a string");
          return 0;
        }
        const char *valptr = jenv->GetStringUTFChars(value, 0);
        arg2 = CSLAddString(arg2,  valptr);
        jenv->ReleaseStringUTFChars(value, valptr);
      }
    }
  }
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (GNMDirection)jarg6; 
  result = (CPLErr)GNMGenericNetworkShadow_ConnectPointsByLines(arg1,arg2,arg3,arg4,arg5,arg6);
  jresult = (jint)result; 
  {
    /* %typemap(freearg) char **options */
    CSLDestroy( arg2 );
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ChangeBlockState(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jboolean jarg3) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  GIntBig arg2 ;
  bool arg3 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2;
  arg3 = jarg3 ? true : false; 
  result = (CPLErr)GNMGenericNetworkShadow_ChangeBlockState(arg1,arg2,arg3);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ChangeAllBlockState_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  bool arg2 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  result = (CPLErr)GNMGenericNetworkShadow_ChangeAllBlockState__SWIG_0(arg1,arg2);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1ChangeAllBlockState_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  GNMGenericNetworkShadow *arg1 = (GNMGenericNetworkShadow *) 0 ;
  CPLErr result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(GNMGenericNetworkShadow **)&jarg1; 
  result = (CPLErr)GNMGenericNetworkShadow_ChangeAllBlockState__SWIG_0(arg1);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_TermProgressCallback_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(ProgressCallback **)&baseptr = *(TermProgressCallback **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_Network_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(GDALMajorObjectShadow **)&baseptr = *(GNMNetworkShadow **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_org_gdal_gnm_gnmJNI_GenericNetwork_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(GNMNetworkShadow **)&baseptr = *(GNMGenericNetworkShadow **)&jarg1;
    return baseptr;
}

#ifdef __cplusplus
}
#endif