javacpp generated code for nix-java's util

jniUtil.cpp

// Generated by JavaCPP version 1.1


#ifdef __APPLE__
    #define _JAVASOFT_JNI_MD_H_

    #define JNIEXPORT __attribute__((visibility("default")))
    #define JNIIMPORT
    #define JNICALL

    typedef int jint;
    typedef long long jlong;
    typedef signed char jbyte;
#endif
#ifdef _WIN32
    #define _JAVASOFT_JNI_MD_H_

    #define JNIEXPORT __declspec(dllexport)
    #define JNIIMPORT __declspec(dllimport)
    #define JNICALL __stdcall

    typedef int jint;
    typedef long long jlong;
    typedef signed char jbyte;
#endif
#include <jni.h>
#ifdef ANDROID
    #include <android/log.h>
#elif defined(__APPLE__) && defined(__OBJC__)
    #include <TargetConditionals.h>
    #include <Foundation/Foundation.h>
#endif
#if defined(ANDROID) || TARGET_OS_IPHONE
    #define NewWeakGlobalRef(obj) NewGlobalRef(obj)
    #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj)
#endif

#include <stddef.h>
#ifndef _WIN32
    #include <stdint.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <exception>
#include <memory>
#include <new>

#define jlong_to_ptr(a) ((void*)(uintptr_t)(a))
#define ptr_to_jlong(a) ((jlong)(uintptr_t)(a))

#if defined(_MSC_VER)
    #define JavaCPP_noinline __declspec(noinline)
    #define JavaCPP_hidden /* hidden by default */
#elif defined(__GNUC__)
    #define JavaCPP_noinline __attribute__((noinline))
    #define JavaCPP_hidden   __attribute__((visibility("hidden")))
#else
    #define JavaCPP_noinline
    #define JavaCPP_hidden
#endif

#include <nix/util/util.hpp>

static JavaVM* JavaCPP_vm = NULL;
static bool JavaCPP_haveAllocObject = false;
static bool JavaCPP_haveNonvirtual = false;
static const char* JavaCPP_classNames[18] = {
        "org/bytedeco/javacpp/Pointer",
        "org/bytedeco/javacpp/Pointer$NativeDeallocator",
        "org/bytedeco/javacpp/Loader",
        "java/nio/Buffer",
        "java/lang/Object",
        "java/lang/NullPointerException",
        "org/bytedeco/javacpp/BytePointer",
        "org/bytedeco/javacpp/ShortPointer",
        "org/bytedeco/javacpp/IntPointer",
        "org/bytedeco/javacpp/LongPointer",
        "org/bytedeco/javacpp/FloatPointer",
        "org/bytedeco/javacpp/DoublePointer",
        "org/bytedeco/javacpp/CharPointer",
        "org/bytedeco/javacpp/PointerPointer",
        "org/bytedeco/javacpp/BoolPointer",
        "org/bytedeco/javacpp/CLongPointer",
        "org/bytedeco/javacpp/SizeTPointer",
        "java/lang/RuntimeException" };
static jclass JavaCPP_classes[18] = { NULL };
static jfieldID JavaCPP_addressFID = NULL;
static jfieldID JavaCPP_positionFID = NULL;
static jfieldID JavaCPP_limitFID = NULL;
static jfieldID JavaCPP_capacityFID = NULL;
static jfieldID JavaCPP_deallocatorFID = NULL;
static jfieldID JavaCPP_ownerAddressFID = NULL;
static jmethodID JavaCPP_initMID = NULL;
static jmethodID JavaCPP_arrayMID = NULL;
static jmethodID JavaCPP_toStringMID = NULL;

static inline void JavaCPP_log(const char* fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
#ifdef ANDROID
    __android_log_vprint(ANDROID_LOG_ERROR, "javacpp", fmt, ap);
#elif defined(__APPLE__) && defined(__OBJC__)
    NSLogv([NSString stringWithUTF8String:fmt], ap);
#else
    vfprintf(stderr, fmt, ap);
    fprintf(stderr, "\n");
#endif
    va_end(ap);
}

static JavaCPP_noinline jclass JavaCPP_getClass(JNIEnv* env, int i) {
    if (JavaCPP_classes[i] == NULL && env->PushLocalFrame(1) == 0) {
        jclass cls = env->FindClass(JavaCPP_classNames[i]);
        if (cls == NULL || env->ExceptionCheck()) {
            JavaCPP_log("Error loading class %s.", JavaCPP_classNames[i]);
            return NULL;
        }
        JavaCPP_classes[i] = (jclass)env->NewWeakGlobalRef(cls);
        if (JavaCPP_classes[i] == NULL || env->ExceptionCheck()) {
            JavaCPP_log("Error creating global reference of class %s.", JavaCPP_classNames[i]);
            return NULL;
        }
        env->PopLocalFrame(NULL);
    }
    return JavaCPP_classes[i];
}

static JavaCPP_noinline jfieldID JavaCPP_getFieldID(JNIEnv* env, int i, const char* name, const char* sig) {
    jclass cls = JavaCPP_getClass(env, i);
    if (cls == NULL) {
        return NULL;
    }
    jfieldID fid = env->GetFieldID(cls, name, sig);
    if (fid == NULL || env->ExceptionCheck()) {
        JavaCPP_log("Error getting field ID of %s/%s", JavaCPP_classNames[i], name);
        return NULL;
    }
    return fid;
}

static JavaCPP_noinline jmethodID JavaCPP_getMethodID(JNIEnv* env, int i, const char* name, const char* sig) {
    jclass cls = JavaCPP_getClass(env, i);
    if (cls == NULL) {
        return NULL;
    }
    jmethodID mid = env->GetMethodID(cls, name, sig);
    if (mid == NULL || env->ExceptionCheck()) {
        JavaCPP_log("Error getting method ID of %s/%s", JavaCPP_classNames[i], name);
        return NULL;
    }
    return mid;
}

static JavaCPP_noinline jmethodID JavaCPP_getStaticMethodID(JNIEnv* env, int i, const char* name, const char* sig) {
    jclass cls = JavaCPP_getClass(env, i);
    if (cls == NULL) {
        return NULL;
    }
    jmethodID mid = env->GetStaticMethodID(cls, name, sig);
    if (mid == NULL || env->ExceptionCheck()) {
        JavaCPP_log("Error getting static method ID of %s/%s", JavaCPP_classNames[i], name);
        return NULL;
    }
    return mid;
}

static JavaCPP_noinline jobject JavaCPP_createPointer(JNIEnv* env, int i, jclass cls = NULL) {
    if (cls == NULL && (cls = JavaCPP_getClass(env, i)) == NULL) {
        return NULL;
    }
    if (JavaCPP_haveAllocObject) {
        return env->AllocObject(cls);
    } else {
        jmethodID mid = env->GetMethodID(cls, "<init>", "()V");
        if (mid == NULL || env->ExceptionCheck()) {
            JavaCPP_log("Error getting default constructor of %s, while VM does not support AllocObject()", JavaCPP_classNames[i]);
            return NULL;
        }
        return env->NewObject(cls, mid);
    }
}

static JavaCPP_noinline void JavaCPP_initPointer(JNIEnv* env, jobject obj, const void* ptr, int size, void* owner, void (*deallocator)(void*)) {
    if (deallocator != NULL) {
        jvalue args[4];
        args[0].j = ptr_to_jlong(ptr);
        args[1].i = size;
        args[2].j = ptr_to_jlong(owner);
        args[3].j = ptr_to_jlong(deallocator);
        if (JavaCPP_haveNonvirtual) {
            env->CallNonvirtualVoidMethodA(obj, JavaCPP_getClass(env, 0), JavaCPP_initMID, args);
        } else {
            env->CallVoidMethodA(obj, JavaCPP_initMID, args);
        }
    } else {
        env->SetLongField(obj, JavaCPP_addressFID, ptr_to_jlong(ptr));
        env->SetIntField(obj, JavaCPP_limitFID, size);
        env->SetIntField(obj, JavaCPP_capacityFID, size);
    }
}

class JavaCPP_hidden JavaCPP_exception : public std::exception {
public:
    JavaCPP_exception(const char* str) throw() {
        if (str == NULL) {
            strcpy(msg, "Unknown exception.");
        } else {
            strncpy(msg, str, sizeof(msg));
            msg[sizeof(msg) - 1] = 0;
        }
    }
    virtual const char* what() const throw() { return msg; }
    char msg[1024];
};

static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) {
    jstring str = NULL;
    try {
        throw;
    } catch (std::exception& e) {
        str = env->NewStringUTF(e.what());
    } catch (...) {
        str = env->NewStringUTF("Unknown exception.");
    }
    jmethodID mid = JavaCPP_getMethodID(env, i, "<init>", "(Ljava/lang/String;)V");
    if (mid == NULL) {
        return NULL;
    }
    return (jthrowable)env->NewObject(JavaCPP_getClass(env, i), mid, str);
}

static JavaCPP_noinline void* JavaCPP_getPointerOwner(JNIEnv* env, jobject obj) {
    if (obj != NULL) {
        jobject deallocator = env->GetObjectField(obj, JavaCPP_deallocatorFID);
        if (deallocator != NULL && env->IsInstanceOf(deallocator, JavaCPP_getClass(env, 1))) {
            return jlong_to_ptr(env->GetLongField(deallocator, JavaCPP_ownerAddressFID));
        }
    }
    return NULL;
}

#include <vector>
template<typename P, typename T = P> class JavaCPP_hidden VectorAdapter {
public:
    VectorAdapter(const P* ptr, typename std::vector<T>::size_type size, void* owner) : ptr((P*)ptr), size(size), owner(owner),
        vec2(ptr ? std::vector<T>((P*)ptr, (P*)ptr + size) : std::vector<T>()), vec(vec2) { }
    VectorAdapter(const std::vector<T>& vec) : ptr(0), size(0), owner(0), vec2(vec), vec(vec2) { }
    VectorAdapter(      std::vector<T>& vec) : ptr(0), size(0), owner(0), vec(vec) { }
    VectorAdapter(const std::vector<T>* vec) : ptr(0), size(0), owner(0), vec(*(std::vector<T>*)vec) { }
    void assign(P* ptr, typename std::vector<T>::size_type size, void* owner) {
        this->ptr = ptr;
        this->size = size;
        this->owner = owner;
        vec.assign(ptr, ptr + size);
    }
    static void deallocate(void* owner) { free(owner); }
    operator P*() {
        if (vec.size() > size) {
            ptr = (P*)malloc(vec.size() * sizeof(P));
        }
        if (ptr) {
            std::copy(vec.begin(), vec.end(), ptr);
        }
        size = vec.size();
        owner = ptr;
        return ptr;
    }
    operator const P*()        { return &vec[0]; }
    operator std::vector<T>&() { return vec; }
    operator std::vector<T>*() { return ptr ? &vec : 0; }
    P* ptr;
    typename std::vector<T>::size_type size;
    void* owner;
    std::vector<T> vec2;
    std::vector<T>& vec;
};

#include <string>
class JavaCPP_hidden StringAdapter {
public:
    StringAdapter(const          char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
        str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
    StringAdapter(const signed   char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
        str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
    StringAdapter(const unsigned char* ptr, size_t size, void* owner) : ptr((char*)ptr), size(size), owner(owner),
        str2(ptr ? (char*)ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0), str(str2) { }
    StringAdapter(const std::string& str) : ptr(0), size(0), owner(0), str2(str), str(str2) { }
    StringAdapter(      std::string& str) : ptr(0), size(0), owner(0), str(str) { }
    StringAdapter(const std::string* str) : ptr(0), size(0), owner(0), str(*(std::string*)str) { }
    void assign(char* ptr, size_t size, void* owner) {
        this->ptr = ptr;
        this->size = size;
        this->owner = owner;
        str.assign(ptr ? ptr : "", ptr ? (size > 0 ? size : strlen((char*)ptr)) : 0);
    }
    static void deallocate(void* owner) { free(owner); }
    operator char*() {
        const char* data = str.data();
        if (str.size() > size) {
            ptr = (char*)calloc(1, str.size()+1);
        }
        if (ptr && memcmp(ptr, data, str.size()) != 0) {
            memcpy(ptr, data, str.size());
            if (size > str.size()) ptr[str.size()] = 0;
        }
        size = str.size();
        owner = ptr;
        return ptr;
    }
    operator       signed   char*() { return (signed   char*)(operator char*)(); }
    operator       unsigned char*() { return (unsigned char*)(operator char*)(); }
    operator const          char*() { return                 str.c_str(); }
    operator const signed   char*() { return (signed   char*)str.c_str(); }
    operator const unsigned char*() { return (unsigned char*)str.c_str(); }
    operator         std::string&() { return str; }
    operator         std::string*() { return ptr ? &str : 0; }
    char* ptr;
    size_t size;
    void* owner;
    std::string str2;
    std::string& str;
};

#ifdef SHARED_PTR_NAMESPACE
template<class T> class SharedPtrAdapter {
public:
    typedef SHARED_PTR_NAMESPACE::shared_ptr<T> S;
    SharedPtrAdapter(const T* ptr, int size, void* owner) : ptr((T*)ptr), size(size), owner(owner),
            sharedPtr2(owner != NULL && owner != ptr ? *(S*)owner : S((T*)ptr)), sharedPtr(sharedPtr2) { }
    SharedPtrAdapter(const S& sharedPtr) : ptr(0), size(0), owner(0), sharedPtr2(sharedPtr), sharedPtr(sharedPtr2) { }
    SharedPtrAdapter(      S& sharedPtr) : ptr(0), size(0), owner(0), sharedPtr(sharedPtr) { }
    void assign(T* ptr, int size, S* owner) {
        this->ptr = ptr;
        this->size = size;
        this->owner = owner;
        this->sharedPtr = owner != NULL && owner != ptr ? *(S*)owner : S((T*)ptr);
    }
    static void deallocate(void* owner) { delete (S*)owner; }
    operator T*() {
        ptr = sharedPtr.get();
        if (owner == NULL || owner == ptr) {
            owner = new S(sharedPtr);
        }
        return ptr;
    }
    operator const T*() { return sharedPtr.get(); }
    operator       S&() { return sharedPtr; }
    operator       S*() { return ptr ? &sharedPtr : 0; }
    T* ptr;
    int size;
    void* owner;
    S sharedPtr2;
    S& sharedPtr;
};
#endif




static void JavaCPP_org_bytedeco_javacpp_BytePointer_deallocateArray(void* p) { delete[] (signed char*)p; }
static void JavaCPP_org_bytedeco_javacpp_ShortPointer_deallocateArray(void* p) { delete[] (short*)p; }
static void JavaCPP_org_bytedeco_javacpp_IntPointer_deallocateArray(void* p) { delete[] (int*)p; }
static void JavaCPP_org_bytedeco_javacpp_LongPointer_deallocateArray(void* p) { delete[] (jlong*)p; }
static void JavaCPP_org_bytedeco_javacpp_FloatPointer_deallocateArray(void* p) { delete[] (float*)p; }
static void JavaCPP_org_bytedeco_javacpp_DoublePointer_deallocateArray(void* p) { delete[] (double*)p; }
static void JavaCPP_org_bytedeco_javacpp_CharPointer_deallocateArray(void* p) { delete[] (unsigned short*)p; }
static void JavaCPP_org_bytedeco_javacpp_PointerPointer_deallocateArray(void* p) { delete[] (void**)p; }
static void JavaCPP_org_bytedeco_javacpp_BoolPointer_deallocateArray(void* p) { delete[] (bool*)p; }
static void JavaCPP_org_bytedeco_javacpp_CLongPointer_deallocateArray(void* p) { delete[] (long*)p; }
static void JavaCPP_org_bytedeco_javacpp_SizeTPointer_deallocateArray(void* p) { delete[] (size_t*)p; }

extern "C" {

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved) {
    JNIEnv* env;
    if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_4 inside JNI_OnLoad().");
        return JNI_ERR;
    }
    if (JavaCPP_vm == vm) {
        return env->GetVersion();
    }
    JavaCPP_vm = vm;
    JavaCPP_haveAllocObject = env->functions->AllocObject != NULL;
    JavaCPP_haveNonvirtual = env->functions->CallNonvirtualVoidMethodA != NULL;
    const char* members[18][1] = {
            { "sizeof" },
            {  },
            {  },
            {  },
            {  },
            {  },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            { "sizeof" },
            {  } };
    int offsets[18][1] = {
            { sizeof(void*) },
            {  },
            {  },
            {  },
            {  },
            {  },
            { sizeof(signed char) },
            { sizeof(short) },
            { sizeof(int) },
            { sizeof(jlong) },
            { sizeof(float) },
            { sizeof(double) },
            { sizeof(unsigned short) },
            { sizeof(void*) },
            { sizeof(bool) },
            { sizeof(long) },
            { sizeof(size_t) },
            {  } };
    int memberOffsetSizes[18] = { 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0 };
    jmethodID putMemberOffsetMID = JavaCPP_getStaticMethodID(env, 2, "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)V");
    if (putMemberOffsetMID == NULL) {
        return JNI_ERR;
    }
    for (int i = 0; i < 18 && !env->ExceptionCheck(); i++) {
        for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) {
            if (env->PushLocalFrame(2) == 0) {
                jvalue args[3];
                args[0].l = env->NewStringUTF(JavaCPP_classNames[i]);
                args[1].l = env->NewStringUTF(members[i][j]);
                args[2].i = offsets[i][j];
                env->CallStaticVoidMethodA(JavaCPP_getClass(env, 2), putMemberOffsetMID, args);
                env->PopLocalFrame(NULL);
            }
        }
    }
    JavaCPP_addressFID = JavaCPP_getFieldID(env, 0, "address", "J");
    if (JavaCPP_addressFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_positionFID = JavaCPP_getFieldID(env, 0, "position", "I");
    if (JavaCPP_positionFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_limitFID = JavaCPP_getFieldID(env, 0, "limit", "I");
    if (JavaCPP_limitFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_capacityFID = JavaCPP_getFieldID(env, 0, "capacity", "I");
    if (JavaCPP_capacityFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_deallocatorFID = JavaCPP_getFieldID(env, 0, "deallocator", "Lorg/bytedeco/javacpp/Pointer$Deallocator;");
    if (JavaCPP_deallocatorFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_ownerAddressFID = JavaCPP_getFieldID(env, 1, "ownerAddress", "J");
    if (JavaCPP_ownerAddressFID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_initMID = JavaCPP_getMethodID(env, 0, "init", "(JIJJ)V");
    if (JavaCPP_initMID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_arrayMID = JavaCPP_getMethodID(env, 3, "array", "()Ljava/lang/Object;");
    if (JavaCPP_arrayMID == NULL) {
        return JNI_ERR;
    }
    JavaCPP_toStringMID = JavaCPP_getMethodID(env, 4, "toString", "()Ljava/lang/String;");
    if (JavaCPP_toStringMID == NULL) {
        return JNI_ERR;
    }
    return env->GetVersion();
}


JNIEXPORT void JNICALL JNI_OnUnload(JavaVM* vm, void* reserved) {
    JNIEnv* env;
    if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
        JavaCPP_log("Could not get JNIEnv for JNI_VERSION_1_4 inside JNI_OnUnLoad().");
        return;
    }
    for (int i = 0; i < 18; i++) {
        env->DeleteWeakGlobalRef((jweak)JavaCPP_classes[i]);
        JavaCPP_classes[i] = NULL;
    }
    JavaCPP_vm = NULL;
}


JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_Pointer_00024NativeDeallocator_deallocate(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) {
    void* allocatedAddress = jlong_to_ptr(arg0);
    void (*deallocatorAddress)(void*) = (void(*)(void*))jlong_to_ptr(arg1);
    if (deallocatorAddress != NULL && allocatedAddress != NULL) {
        (*deallocatorAddress)(allocatedAddress);
    }

}



JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_Pointer_allocate(JNIEnv* env, jobject obj, jobject arg0) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)env->GetDirectBufferAddress(arg0);
    void* rptr = ptr0;
    jint rcapacity = 1;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, NULL);
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    jobject rarg = NULL;
    void* rptr;
    rptr = memchr(ptr0, arg1, arg2);
    if (rptr == ptr0) {
        rarg = arg0;
    } else if (rptr != NULL) {
        rarg = JavaCPP_createPointer(env, 0);
        if (rarg != NULL) {
            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
        }
    }
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_asDirectBuffer(JNIEnv* env, jobject obj) {
    char* ptr = (char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jint size = env->GetIntField(obj, JavaCPP_limitFID);
    size -= position;
    jobject rarg = NULL;
    char* rptr;
    rptr = ptr;
    jint rcapacity = size;
    if (rptr != NULL) {
        rarg = env->NewDirectByteBuffer((void*)rptr, rcapacity * sizeof(rptr[0]));
    }
    return rarg;
}
JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_Pointer_memcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jint rarg = 0;
    int rvalue = memcmp(ptr0, ptr1, arg2);
    rarg = (jint)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jobject rarg = NULL;
    void* rptr;
    rptr = memcpy(ptr0, ptr1, arg2);
    if (rptr == ptr0) {
        rarg = arg0;
    } else if (rptr == ptr1) {
        rarg = arg1;
    } else if (rptr != NULL) {
        rarg = JavaCPP_createPointer(env, 0);
        if (rarg != NULL) {
            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
        }
    }
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memmove(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jobject rarg = NULL;
    void* rptr;
    rptr = memmove(ptr0, ptr1, arg2);
    if (rptr == ptr0) {
        rarg = arg0;
    } else if (rptr == ptr1) {
        rarg = arg1;
    } else if (rptr != NULL) {
        rarg = JavaCPP_createPointer(env, 0);
        if (rarg != NULL) {
            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
        }
    }
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_Pointer_memset(JNIEnv* env, jclass cls, jobject arg0, jint arg1, jlong arg2) {
    char* ptr0 = arg0 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    jobject rarg = NULL;
    void* rptr;
    rptr = memset(ptr0, arg1, arg2);
    if (rptr == ptr0) {
        rarg = arg0;
    } else if (rptr != NULL) {
        rarg = JavaCPP_createPointer(env, 0);
        if (rarg != NULL) {
            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
        }
    }
    return rarg;
}

JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_get___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jbyte JNICALL Java_org_bytedeco_javacpp_BytePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jbyte rarg = 0;
    signed char rvalue = ptr[arg0];
    rarg = (jbyte)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_put___3BII(JNIEnv* env, jobject obj, jbyteArray arg0, jint arg1, jint arg2) {
    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    signed char* ptr0 = arg0 == NULL ? NULL : (jbyte*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_put__IB(JNIEnv* env, jobject obj, jint arg0, jbyte arg1) {
    signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 6))) {
        return;
    }
    signed char* rptr = new (std::nothrow) signed char[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BytePointer_deallocateArray);
}

JNIEXPORT jshort JNICALL Java_org_bytedeco_javacpp_ShortPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jshort rarg = 0;
    short rvalue = ptr[arg0];
    rarg = (jshort)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_get___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_put__IS(JNIEnv* env, jobject obj, jint arg0, jshort arg1) {
    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_put___3SII(JNIEnv* env, jobject obj, jshortArray arg0, jint arg1, jint arg2) {
    short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    short* ptr0 = arg0 == NULL ? NULL : (jshort*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 7))) {
        return;
    }
    short* rptr = new (std::nothrow) short[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_ShortPointer_deallocateArray);
}

JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_IntPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jint rarg = 0;
    int rvalue = ptr[arg0];
    rarg = (jint)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_get___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_put___3III(JNIEnv* env, jobject obj, jintArray arg0, jint arg1, jint arg2) {
    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    int* ptr0 = arg0 == NULL ? NULL : (jint*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_IntPointer_put__II(JNIEnv* env, jobject obj, jint arg0, jint arg1) {
    int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_IntPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 8))) {
        return;
    }
    int* rptr = new (std::nothrow) int[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_IntPointer_deallocateArray);
}

JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_LongPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jlong rarg = 0;
    jlong rvalue = ptr[arg0];
    rarg = (jlong)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_get___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_put__IJ(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_put___3JII(JNIEnv* env, jobject obj, jlongArray arg0, jint arg1, jint arg2) {
    jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jlong* ptr0 = arg0 == NULL ? NULL : (jlong*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 9))) {
        return;
    }
    jlong* rptr = new (std::nothrow) jlong[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_LongPointer_deallocateArray);
}

JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_FloatPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jfloat rarg = 0;
    float rvalue = ptr[arg0];
    rarg = (jfloat)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_get___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_put__IF(JNIEnv* env, jobject obj, jint arg0, jfloat arg1) {
    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_put___3FII(JNIEnv* env, jobject obj, jfloatArray arg0, jint arg1, jint arg2) {
    float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    float* ptr0 = arg0 == NULL ? NULL : (jfloat*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 10))) {
        return;
    }
    float* rptr = new (std::nothrow) float[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_FloatPointer_deallocateArray);
}

JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_DoublePointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jdouble rarg = 0;
    double rvalue = ptr[arg0];
    rarg = (jdouble)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_get___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_put__ID(JNIEnv* env, jobject obj, jint arg0, jdouble arg1) {
    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_put___3DII(JNIEnv* env, jobject obj, jdoubleArray arg0, jint arg1, jint arg2) {
    double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    double* ptr0 = arg0 == NULL ? NULL : (jdouble*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 11))) {
        return;
    }
    double* rptr = new (std::nothrow) double[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_DoublePointer_deallocateArray);
}

JNIEXPORT jchar JNICALL Java_org_bytedeco_javacpp_CharPointer_get__I(JNIEnv* env, jobject obj, jint arg0) {
    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jchar rarg = 0;
    unsigned short rvalue = ptr[arg0];
    rarg = (jchar)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_get___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr0 + arg1, ptr, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_put___3CII(JNIEnv* env, jobject obj, jcharArray arg0, jint arg1, jint arg2) {
    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    unsigned short* ptr0 = arg0 == NULL ? NULL : (jchar*)env->GetPrimitiveArrayCritical(arg0, NULL);
    jobject rarg = obj;
    memcpy(ptr, ptr0 + arg1, arg2 * sizeof(*ptr0));
    if (arg0 != NULL) env->ReleasePrimitiveArrayCritical(arg0, ptr0, 0);
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CharPointer_put__IC(JNIEnv* env, jobject obj, jint arg0, jchar arg1) {
    unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_CharPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 12))) {
        return;
    }
    unsigned short* rptr = new (std::nothrow) unsigned short[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CharPointer_deallocateArray);
}

JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jclass arg0, jint arg1) {
    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = NULL;
    void* rptr;
    rptr = ptr[arg1];
    if (rptr != NULL) {
        rarg = JavaCPP_createPointer(env, 0, arg0);
        if (rarg != NULL) {
            env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr));
        }
    }
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_PointerPointer_put(JNIEnv* env, jobject obj, jint arg0, jobject arg1) {
    void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jobject rarg = obj;
    ptr[arg0] = ptr1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 13))) {
        return;
    }
    void** rptr = new (std::nothrow) void*[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_PointerPointer_deallocateArray);
}

JNIEXPORT jboolean JNICALL Java_org_bytedeco_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jint arg0) {
    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jboolean rarg = 0;
    bool rvalue = (bool)ptr[arg0];
    rarg = (jboolean)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BoolPointer_put(JNIEnv* env, jobject obj, jint arg0, jboolean arg1) {
    bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = (bool)arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 14))) {
        return;
    }
    bool* rptr = new (std::nothrow) bool[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BoolPointer_deallocateArray);
}

JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jint arg0) {
    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jlong rarg = 0;
    long rvalue = (long)ptr[arg0];
    rarg = (jlong)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_CLongPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
    long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = (long)arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 15))) {
        return;
    }
    long* rptr = new (std::nothrow) long[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CLongPointer_deallocateArray);
}

JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jint arg0) {
    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jlong rarg = 0;
    size_t rvalue = (size_t)ptr[arg0];
    rarg = (jlong)rvalue;
    return rarg;
}
JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_SizeTPointer_put(JNIEnv* env, jobject obj, jint arg0, jlong arg1) {
    size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID));
    if (ptr == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "This pointer address is NULL.");
        return 0;
    }
    jint position = env->GetIntField(obj, JavaCPP_positionFID);
    ptr += position;
    jobject rarg = obj;
    ptr[arg0] = (size_t)arg1;
    return rarg;
}
JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jint arg0) {
    if (!env->IsSameObject(env->GetObjectClass(obj), JavaCPP_getClass(env, 16))) {
        return;
    }
    size_t* rptr = new (std::nothrow) size_t[arg0];
    jint rcapacity = arg0;
    JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_SizeTPointer_deallocateArray);
}

JNIEXPORT jstring JNICALL Java_org_g_1node_nix_util_Util_createId(JNIEnv* env, jclass cls) {
    jstring rarg = NULL;
    const char* rptr;
    jthrowable exc = NULL;
    try {
        StringAdapter radapter(nix::util::createId());
        rptr = radapter;
        if (rptr != NULL) {
            rarg = env->NewStringUTF(rptr);
        }
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT void JNICALL Java_org_g_1node_nix_util_Util_deblankString(JNIEnv* env, jclass cls, jobject arg0) {
    signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    jint size0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_limitFID);
    void* owner0 = JavaCPP_getPointerOwner(env, arg0);
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    size0 -= position0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jthrowable exc = NULL;
    try {
        nix::util::deblankString((std::string&)adapter0);
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    signed char* rptr0 = adapter0;
    jint rsize0 = (jint)adapter0.size;
    void* rowner0 = adapter0.owner;
    if (rptr0 != ptr0) {
        JavaCPP_initPointer(env, arg0, rptr0, rsize0, rowner0, &StringAdapter::deallocate);
    } else {
        env->SetIntField(arg0, JavaCPP_limitFID, rsize0 + position0);
    }
    if (exc != NULL) {
        env->Throw(exc);
    }
}
JNIEXPORT jstring JNICALL Java_org_g_1node_nix_util_Util_nameSanitizer(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jstring rarg = NULL;
    const char* rptr;
    jthrowable exc = NULL;
    try {
        StringAdapter radapter(nix::util::nameSanitizer((std::string&)adapter0));
        rptr = radapter;
        if (rptr != NULL) {
            rarg = env->NewStringUTF(rptr);
        }
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_nameCheck(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::nameCheck((std::string&)adapter0);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jstring JNICALL Java_org_g_1node_nix_util_Util_unitSanitizer(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jstring rarg = NULL;
    const char* rptr;
    jthrowable exc = NULL;
    try {
        StringAdapter radapter(nix::util::unitSanitizer((std::string&)adapter0));
        rptr = radapter;
        if (rptr != NULL) {
            rarg = env->NewStringUTF(rptr);
        }
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isSIUnit(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isSIUnit((std::string&)adapter0);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isAtomicSIUnit(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isAtomicSIUnit((std::string&)adapter0);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isCompoundSIUnit(JNIEnv* env, jclass cls, jstring arg0) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isCompoundSIUnit((std::string&)adapter0);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isScalable__Lorg_g_1node_nix_internal_VectorUtils_00024StringVector_2Lorg_g_1node_nix_internal_VectorUtils_00024StringVector_2(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
    ::std::vector<std::string>* ptr0 = arg0 == NULL ? NULL : (::std::vector<std::string>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    if (ptr0 == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "Pointer address of argument 0 is NULL.");
        return 0;
    }
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    ::std::vector<std::string>* ptr1 = arg1 == NULL ? NULL : (::std::vector<std::string>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    if (ptr1 == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "Pointer address of argument 1 is NULL.");
        return 0;
    }
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isScalable(*(const ::std::vector<std::string>*)ptr0, *(const ::std::vector<std::string>*)ptr1);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isScalable__Ljava_lang_String_2Ljava_lang_String_2(JNIEnv* env, jclass cls, jstring arg0, jstring arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    const char* ptr1 = arg1 == NULL ? NULL : env->GetStringUTFChars(arg1, NULL);
    jint size1 = 0;
    void* owner1 = (void*)ptr1;
    StringAdapter adapter1(ptr1, size1, owner1);
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isScalable((std::string&)adapter0, (std::string&)adapter1);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (arg1 != NULL) env->ReleaseStringUTFChars(arg1, ptr1);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jboolean JNICALL Java_org_g_1node_nix_util_Util_isSetAtSamePos(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) {
    ::std::vector<std::string>* ptr0 = arg0 == NULL ? NULL : (::std::vector<std::string>*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID));
    if (ptr0 == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "Pointer address of argument 0 is NULL.");
        return 0;
    }
    jint position0 = arg0 == NULL ? 0 : env->GetIntField(arg0, JavaCPP_positionFID);
    ptr0 += position0;
    ::std::vector<std::string>* ptr1 = arg1 == NULL ? NULL : (::std::vector<std::string>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    if (ptr1 == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "Pointer address of argument 1 is NULL.");
        return 0;
    }
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jboolean rarg = 0;
    jthrowable exc = NULL;
    try {
        unsigned char rvalue = nix::util::isSetAtSamePos(*(const ::std::vector<std::string>*)ptr0, *(const ::std::vector<std::string>*)ptr1);
        rarg = (jboolean)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jdouble JNICALL Java_org_g_1node_nix_util_Util_getSIScaling(JNIEnv* env, jclass cls, jstring arg0, jstring arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    const char* ptr1 = arg1 == NULL ? NULL : env->GetStringUTFChars(arg1, NULL);
    jint size1 = 0;
    void* owner1 = (void*)ptr1;
    StringAdapter adapter1(ptr1, size1, owner1);
    jdouble rarg = 0;
    jthrowable exc = NULL;
    try {
        double rvalue = nix::util::getSIScaling((std::string&)adapter0, (std::string&)adapter1);
        rarg = (jdouble)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (arg1 != NULL) env->ReleaseStringUTFChars(arg1, ptr1);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT void JNICALL Java_org_g_1node_nix_util_Util_splitUnit(JNIEnv* env, jclass cls, jstring arg0, jobject arg1, jobject arg2, jobject arg3) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    jint size1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_limitFID);
    void* owner1 = JavaCPP_getPointerOwner(env, arg1);
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    size1 -= position1;
    StringAdapter adapter1(ptr1, size1, owner1);
    signed char* ptr2 = arg2 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg2, JavaCPP_addressFID));
    jint size2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_limitFID);
    void* owner2 = JavaCPP_getPointerOwner(env, arg2);
    jint position2 = arg2 == NULL ? 0 : env->GetIntField(arg2, JavaCPP_positionFID);
    ptr2 += position2;
    size2 -= position2;
    StringAdapter adapter2(ptr2, size2, owner2);
    signed char* ptr3 = arg3 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg3, JavaCPP_addressFID));
    jint size3 = arg3 == NULL ? 0 : env->GetIntField(arg3, JavaCPP_limitFID);
    void* owner3 = JavaCPP_getPointerOwner(env, arg3);
    jint position3 = arg3 == NULL ? 0 : env->GetIntField(arg3, JavaCPP_positionFID);
    ptr3 += position3;
    size3 -= position3;
    StringAdapter adapter3(ptr3, size3, owner3);
    jthrowable exc = NULL;
    try {
        nix::util::splitUnit((std::string&)adapter0, (std::string&)adapter1, (std::string&)adapter2, (std::string&)adapter3);
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    signed char* rptr1 = adapter1;
    jint rsize1 = (jint)adapter1.size;
    void* rowner1 = adapter1.owner;
    if (rptr1 != ptr1) {
        JavaCPP_initPointer(env, arg1, rptr1, rsize1, rowner1, &StringAdapter::deallocate);
    } else {
        env->SetIntField(arg1, JavaCPP_limitFID, rsize1 + position1);
    }
    signed char* rptr2 = adapter2;
    jint rsize2 = (jint)adapter2.size;
    void* rowner2 = adapter2.owner;
    if (rptr2 != ptr2) {
        JavaCPP_initPointer(env, arg2, rptr2, rsize2, rowner2, &StringAdapter::deallocate);
    } else {
        env->SetIntField(arg2, JavaCPP_limitFID, rsize2 + position2);
    }
    signed char* rptr3 = adapter3;
    jint rsize3 = (jint)adapter3.size;
    void* rowner3 = adapter3.owner;
    if (rptr3 != ptr3) {
        JavaCPP_initPointer(env, arg3, rptr3, rsize3, rowner3, &StringAdapter::deallocate);
    } else {
        env->SetIntField(arg3, JavaCPP_limitFID, rsize3 + position3);
    }
    if (exc != NULL) {
        env->Throw(exc);
    }
}
JNIEXPORT void JNICALL Java_org_g_1node_nix_util_Util_splitCompoundUnit(JNIEnv* env, jclass cls, jstring arg0, jobject arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    ::std::vector<std::string>* ptr1 = arg1 == NULL ? NULL : (::std::vector<std::string>*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID));
    if (ptr1 == NULL) {
        env->ThrowNew(JavaCPP_getClass(env, 5), "Pointer address of argument 1 is NULL.");
        return;
    }
    jint position1 = arg1 == NULL ? 0 : env->GetIntField(arg1, JavaCPP_positionFID);
    ptr1 += position1;
    jthrowable exc = NULL;
    try {
        nix::util::splitCompoundUnit((std::string&)adapter0, *ptr1);
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
}
JNIEXPORT jdouble JNICALL Java_org_g_1node_nix_util_Util_convertToSeconds__Ljava_lang_String_2D(JNIEnv* env, jclass cls, jstring arg0, jdouble arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jdouble rarg = 0;
    jthrowable exc = NULL;
    try {
        double rvalue = nix::util::convertToSeconds((std::string&)adapter0, arg1);
        rarg = (jdouble)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jlong JNICALL Java_org_g_1node_nix_util_Util_convertToSeconds__Ljava_lang_String_2J(JNIEnv* env, jclass cls, jstring arg0, jlong arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jlong rarg = 0;
    jthrowable exc = NULL;
    try {
        jlong rvalue = nix::util::convertToSeconds((std::string&)adapter0, arg1);
        rarg = (jlong)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jlong JNICALL Java_org_g_1node_nix_util_Util_convertToKelvin__Ljava_lang_String_2J(JNIEnv* env, jclass cls, jstring arg0, jlong arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jlong rarg = 0;
    jthrowable exc = NULL;
    try {
        jlong rvalue = nix::util::convertToKelvin((std::string&)adapter0, arg1);
        rarg = (jlong)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT jdouble JNICALL Java_org_g_1node_nix_util_Util_convertToKelvin__Ljava_lang_String_2D(JNIEnv* env, jclass cls, jstring arg0, jdouble arg1) {
    const char* ptr0 = arg0 == NULL ? NULL : env->GetStringUTFChars(arg0, NULL);
    jint size0 = 0;
    void* owner0 = (void*)ptr0;
    StringAdapter adapter0(ptr0, size0, owner0);
    jdouble rarg = 0;
    jthrowable exc = NULL;
    try {
        double rvalue = nix::util::convertToKelvin((std::string&)adapter0, arg1);
        rarg = (jdouble)rvalue;
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseStringUTFChars(arg0, ptr0);
    if (exc != NULL) {
        env->Throw(exc);
    }
    return rarg;
}
JNIEXPORT void JNICALL Java_org_g_1node_nix_util_Util_applyPolynomial(JNIEnv* env, jclass cls, jdoubleArray arg0, jdouble arg1, jdoubleArray arg2, jdoubleArray arg3, jlong arg4) {
    double* ptr0 = arg0 == NULL ? NULL : env->GetDoubleArrayElements(arg0, NULL);
    jint size0 = arg0 == NULL ? 0 : env->GetArrayLength(arg0);
    void* owner0 = (void*)ptr0;
    VectorAdapter< double > adapter0(ptr0, size0, owner0);
    double* ptr2 = arg2 == NULL ? NULL : env->GetDoubleArrayElements(arg2, NULL);
    double* ptr3 = arg3 == NULL ? NULL : env->GetDoubleArrayElements(arg3, NULL);
    jthrowable exc = NULL;
    try {
        nix::util::applyPolynomial(adapter0, arg1, (const double*)ptr2, ptr3, (size_t)arg4);
    } catch (...) {
        exc = JavaCPP_handleException(env, 17);
    }

    if (arg0 != NULL) env->ReleaseDoubleArrayElements(arg0, (jdouble*)ptr0, 0);
    if (arg2 != NULL) env->ReleaseDoubleArrayElements(arg2, (jdouble*)ptr2, 0);
    if (arg3 != NULL) env->ReleaseDoubleArrayElements(arg3, (jdouble*)ptr3, 0);
    if (exc != NULL) {
        env->Throw(exc);
    }
}

}