diff --git a/.gitignore b/.gitignore index a143d7a84..fdb418169 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -/target/ +target/ # Mac .DS_Store diff --git a/examples/include/test.hpp b/examples/include/test.hpp new file mode 100644 index 000000000..0cf831fbf --- /dev/null +++ b/examples/include/test.hpp @@ -0,0 +1,17 @@ +#ifndef TEST_HPP +#define TEST_HPP + +#include "caffe/caffe.hpp" + +namespace test { + +class Test { + public: + std::string test() { + return "blah"; + } +}; + +} + +#endif diff --git a/examples/pom.xml b/examples/pom.xml new file mode 100644 index 000000000..cf321c954 --- /dev/null +++ b/examples/pom.xml @@ -0,0 +1,42 @@ + + 4.0.0 + + test + test + 0.1-SNAPSHOT + + + + repo-id + repo-name + https://oss.sonatype.org/content/repositories/snapshots + + + + + + org.bytedeco.javacpp-presets + opencv + 3.1.0-1.2.5-SNAPSHOT + + + org.bytedeco.javacpp-presets + opencv + 3.1.0-1.2.5-SNAPSHOT + include + + + org.bytedeco.javacpp-presets + caffe + master-1.2.5-SNAPSHOT + + + org.bytedeco.javacpp-presets + caffe + master-1.2.5-SNAPSHOT + include + + + diff --git a/examples/src/jnitest.cpp b/examples/src/jnitest.cpp new file mode 100644 index 000000000..a0bb45c27 --- /dev/null +++ b/examples/src/jnitest.cpp @@ -0,0 +1,1801 @@ +// Generated by JavaCPP version unknown: DO NOT EDIT THIS FILE + +#define SHARED_PTR_NAMESPACE boost +#define USE_LEVELDB +#define USE_LMDB +#define USE_OPENCV + +#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; +#elif defined(__GNUC__) + #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 + +#include + +#ifdef __ANDROID__ + #include +#elif defined(__APPLE__) && defined(__OBJC__) + #include + #include +#endif + +#ifdef __linux__ + #include +#elif defined(__APPLE__) + #include + #include +#elif defined(_WIN32) + #define NOMINMAX + #include + #include +#endif + +#if defined(__ANDROID__) || TARGET_OS_IPHONE + #define NewWeakGlobalRef(obj) NewGlobalRef(obj) + #define DeleteWeakGlobalRef(obj) DeleteGlobalRef(obj) +#endif + +#include +#include +#ifndef _WIN32 + #include +#endif +#include +#include +#include +#include +#include +#include + +#if defined(NATIVE_ALLOCATOR) && defined(NATIVE_DEALLOCATOR) + void* operator new(std::size_t size, const std::nothrow_t&) throw() { + return NATIVE_ALLOCATOR(size); + } + void* operator new[](std::size_t size, const std::nothrow_t&) throw() { + return NATIVE_ALLOCATOR(size); + } + void* operator new(std::size_t size) throw(std::bad_alloc) { + return NATIVE_ALLOCATOR(size); + } + void* operator new[](std::size_t size) throw(std::bad_alloc) { + return NATIVE_ALLOCATOR(size); + } + void operator delete(void* ptr) throw() { + NATIVE_DEALLOCATOR(ptr); + } + void operator delete[](void* ptr) throw() { + NATIVE_DEALLOCATOR(ptr); + } +#endif + +#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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "opencv_adapters.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "caffe/caffe.hpp" +#include "caffe/util/device_alternate.hpp" +#include "google/protobuf/stubs/common.h" +#include "google/protobuf/descriptor.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/message.h" +#include "caffe/common.hpp" +#include "caffe/proto/caffe.pb.h" +#include "caffe/util/blocking_queue.hpp" +#include "caffe/util/math_functions.hpp" +#include "caffe/syncedmem.hpp" +#include "caffe/blob.hpp" +#include "caffe/data_transformer.hpp" +#include "caffe/filler.hpp" +#include "caffe/internal_thread.hpp" +#include "caffe/util/hdf5.hpp" +#include "caffe/layers/base_data_layer.hpp" +#include "caffe/layers/data_layer.hpp" +#include "caffe/layers/dummy_data_layer.hpp" +#include "caffe/layers/hdf5_data_layer.hpp" +#include "caffe/layers/hdf5_output_layer.hpp" +#include "caffe/layers/image_data_layer.hpp" +#include "caffe/layers/memory_data_layer.hpp" +#include "caffe/layers/window_data_layer.hpp" +#include "caffe/layer_factory.hpp" +#include "caffe/layer.hpp" +#include "caffe/layers/accuracy_layer.hpp" +#include "caffe/layers/loss_layer.hpp" +#include "caffe/layers/contrastive_loss_layer.hpp" +#include "caffe/layers/euclidean_loss_layer.hpp" +#include "caffe/layers/hinge_loss_layer.hpp" +#include "caffe/layers/infogain_loss_layer.hpp" +#include "caffe/layers/multinomial_logistic_loss_layer.hpp" +#include "caffe/layers/sigmoid_cross_entropy_loss_layer.hpp" +#include "caffe/layers/softmax_loss_layer.hpp" +#include "caffe/layers/neuron_layer.hpp" +#include "caffe/layers/absval_layer.hpp" +#include "caffe/layers/bnll_layer.hpp" +#include "caffe/layers/dropout_layer.hpp" +#include "caffe/layers/exp_layer.hpp" +#include "caffe/layers/log_layer.hpp" +#include "caffe/layers/power_layer.hpp" +#include "caffe/layers/relu_layer.hpp" +#include "caffe/layers/cudnn_relu_layer.hpp" +#include "caffe/layers/sigmoid_layer.hpp" +#include "caffe/layers/cudnn_sigmoid_layer.hpp" +#include "caffe/layers/tanh_layer.hpp" +#include "caffe/layers/cudnn_tanh_layer.hpp" +#include "caffe/layers/threshold_layer.hpp" +#include "caffe/layers/prelu_layer.hpp" +#include "caffe/layers/argmax_layer.hpp" +#include "caffe/layers/batch_norm_layer.hpp" +#include "caffe/layers/batch_reindex_layer.hpp" +#include "caffe/layers/concat_layer.hpp" +#include "caffe/layers/eltwise_layer.hpp" +#include "caffe/layers/embed_layer.hpp" +#include "caffe/layers/filter_layer.hpp" +#include "caffe/layers/flatten_layer.hpp" +#include "caffe/layers/inner_product_layer.hpp" +#include "caffe/layers/mvn_layer.hpp" +#include "caffe/layers/reshape_layer.hpp" +#include "caffe/layers/reduction_layer.hpp" +#include "caffe/layers/silence_layer.hpp" +#include "caffe/layers/softmax_layer.hpp" +#include "caffe/layers/cudnn_softmax_layer.hpp" +#include "caffe/layers/split_layer.hpp" +#include "caffe/layers/slice_layer.hpp" +#include "caffe/layers/tile_layer.hpp" +#include "caffe/net.hpp" +#include "caffe/parallel.hpp" +#include "caffe/solver.hpp" +#include "caffe/solver_factory.hpp" +#include "caffe/sgd_solvers.hpp" +#include "caffe/layers/input_layer.hpp" +#include "caffe/layers/parameter_layer.hpp" +#include "caffe/layers/base_conv_layer.hpp" +#include "caffe/layers/conv_layer.hpp" +#include "caffe/layers/crop_layer.hpp" +#include "caffe/layers/deconv_layer.hpp" +#include "caffe/layers/cudnn_conv_layer.hpp" +#include "caffe/layers/im2col_layer.hpp" +#include "caffe/layers/lrn_layer.hpp" +#include "caffe/layers/cudnn_lrn_layer.hpp" +#include "caffe/layers/cudnn_lcn_layer.hpp" +#include "caffe/layers/pooling_layer.hpp" +#include "caffe/layers/cudnn_pooling_layer.hpp" +#include "caffe/layers/spp_layer.hpp" +#include "caffe/layers/recurrent_layer.hpp" +#include "caffe/layers/lstm_layer.hpp" +#include "caffe/layers/rnn_layer.hpp" +#include "caffe/util/benchmark.hpp" +#include "caffe/util/db.hpp" +#include "caffe/util/db_leveldb.hpp" +#include "caffe/util/db_lmdb.hpp" +#include "caffe/util/io.hpp" +#include "caffe/util/rng.hpp" +#include "caffe/util/im2col.hpp" +#include "caffe/util/insert_splits.hpp" +#include "caffe/util/mkl_alternate.hpp" +#include "caffe/util/upgrade_proto.hpp" +#include "caffe/util/cudnn.hpp" +#include "test.hpp" + +static JavaVM* JavaCPP_vm = NULL; +static bool JavaCPP_haveAllocObject = false; +static bool JavaCPP_haveNonvirtual = false; +static const char* JavaCPP_classNames[20] = { + "org/bytedeco/javacpp/Pointer", + "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/String", + "org/bytedeco/javacpp/Pointer$NativeDeallocator", + "org/bytedeco/javacpp/Loader", + "java/nio/Buffer", + "java/lang/Object", + "java/lang/NullPointerException", + "my/test$Test", + "java/lang/RuntimeException" }; +static jclass JavaCPP_classes[20] = { 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_stringMID = NULL; +static jmethodID JavaCPP_getBytesMID = 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 inline jlong JavaCPP_physicalBytes() { + jlong size = 0; +#ifdef __linux__ + FILE *file = fopen("/proc/self/statm", "r"); + if (file != NULL) { + long long virtual_size = 0, resident_size = 0; + if (fscanf(file, "%lld %lld", &virtual_size, &resident_size) == 2) { + size = (jlong)(resident_size * getpagesize()); + } + fclose(file); + } +#elif defined(__APPLE__) + task_basic_info info = {}; + mach_msg_type_number_t count = TASK_BASIC_INFO_COUNT; + task_info(current_task(), TASK_BASIC_INFO, (task_info_t)&info, &count); + size = (jlong)info.resident_size; +#elif defined(_WIN32) + PROCESS_MEMORY_COUNTERS counters; + if (GetProcessMemoryInfo(GetCurrentProcess(), &counters, sizeof(counters))) { + size = (jlong)counters.WorkingSetSize; + } +#endif + return size; +} + +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, "", "(Lorg/bytedeco/javacpp/Pointer;)V"); + if (mid == NULL || env->ExceptionCheck()) { + JavaCPP_log("Error getting Pointer constructor of %s, while VM does not support AllocObject()", JavaCPP_classNames[i]); + return NULL; + } + return env->NewObject(cls, mid, NULL); + } +} + +static JavaCPP_noinline void JavaCPP_initPointer(JNIEnv* env, jobject obj, const void* ptr, jlong size, void* owner, void (*deallocator)(void*)) { + if (deallocator != NULL) { + jvalue args[4]; + args[0].j = ptr_to_jlong(ptr); + args[1].j = 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->SetLongField(obj, JavaCPP_limitFID, (jlong)size); + env->SetLongField(obj, JavaCPP_capacityFID, (jlong)size); + } +} + +static JavaCPP_noinline jstring JavaCPP_createString(JNIEnv* env, const char* ptr) { + if (ptr == NULL) { + return NULL; + } +#ifdef MODIFIED_UTF8_STRING + return env->NewStringUTF(ptr); +#else + size_t length = strlen(ptr); + jbyteArray bytes = env->NewByteArray(length < INT_MAX ? length : INT_MAX); + env->SetByteArrayRegion(bytes, 0, length < INT_MAX ? length : INT_MAX, (signed char*)ptr); + return (jstring)env->NewObject(JavaCPP_getClass(env, 12), JavaCPP_stringMID, bytes); +#endif +} + +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]; +}; + +#ifndef GENERIC_EXCEPTION_CLASS +#define GENERIC_EXCEPTION_CLASS std::exception +#endif +static JavaCPP_noinline jthrowable JavaCPP_handleException(JNIEnv* env, int i) { + jstring str = NULL; + try { + throw; + } catch (GENERIC_EXCEPTION_CLASS& e) { + str = JavaCPP_createString(env, e.what()); + } catch (...) { + str = JavaCPP_createString(env, "Unknown exception."); + } + jmethodID mid = JavaCPP_getMethodID(env, i, "", "(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, 13))) { + return jlong_to_ptr(env->GetLongField(deallocator, JavaCPP_ownerAddressFID)); + } + } + return NULL; +} + +#include +template class JavaCPP_hidden VectorAdapter { +public: + VectorAdapter(const P* ptr, typename std::vector::size_type size, void* owner) : ptr((P*)ptr), size(size), owner(owner), + vec2(ptr ? std::vector((P*)ptr, (P*)ptr + size) : std::vector()), vec(vec2) { } + VectorAdapter(const std::vector& vec) : ptr(0), size(0), owner(0), vec2(vec), vec(vec2) { } + VectorAdapter( std::vector& vec) : ptr(0), size(0), owner(0), vec(vec) { } + VectorAdapter(const std::vector* vec) : ptr(0), size(0), owner(0), vec(*(std::vector*)vec) { } + void assign(P* ptr, typename std::vector::size_type size, void* owner) { + this->ptr = ptr; + this->size = size; + this->owner = owner; + vec.assign(ptr, ptr + size); + } + static void deallocate(void* owner) { operator delete(owner); } + operator P*() { + if (vec.size() > size) { + ptr = (P*)(operator new(sizeof(P) * vec.size(), std::nothrow_t())); + } + 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&() { return vec; } + operator std::vector*() { return ptr ? &vec : 0; } + P* ptr; + typename std::vector::size_type size; + void* owner; + std::vector vec2; + std::vector& vec; +}; + +#include +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); + } + void assign(const char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); } + void assign(const signed char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); } + void assign(const unsigned char* ptr, size_t size, void* owner) { assign((char*)ptr, size, owner); } + static void deallocate(void* owner) { delete[] (char*)owner; } + operator char*() { + const char* data = str.data(); + if (str.size() > size) { + ptr = new (std::nothrow) char[str.size()+1]; + if (ptr) memset(ptr, 0, 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 SharedPtrAdapter { +public: + typedef SHARED_PTR_NAMESPACE::shared_ptr S; + SharedPtrAdapter(const T* ptr, size_t 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) { } + SharedPtrAdapter(const S* sharedPtr) : ptr(0), size(0), owner(0), sharedPtr(*(S*)sharedPtr) { } + void assign(T* ptr, size_t 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 &sharedPtr; } + T* ptr; + size_t size; + void* owner; + S sharedPtr2; + S& sharedPtr; +}; +#endif + +#ifdef UNIQUE_PTR_NAMESPACE +template class UniquePtrAdapter { +public: + typedef UNIQUE_PTR_NAMESPACE::unique_ptr U; + UniquePtrAdapter(const T* ptr, size_t size, void* owner) : ptr((T*)ptr), size(size), owner(owner), + uniquePtr2(owner != NULL && owner != ptr ? U() : U((T*)ptr)), + uniquePtr(owner != NULL && owner != ptr ? *(U*)owner : uniquePtr2) { } + UniquePtrAdapter(const U& uniquePtr) : ptr(0), size(0), owner(0), uniquePtr((U&)uniquePtr) { } + UniquePtrAdapter( U& uniquePtr) : ptr(0), size(0), owner(0), uniquePtr(uniquePtr) { } + UniquePtrAdapter(const U* uniquePtr) : ptr(0), size(0), owner(0), uniquePtr(*(U*)uniquePtr) { } + void assign(T* ptr, size_t size, U* owner) { + this->ptr = ptr; + this->size = size; + this->owner = owner; + this->uniquePtr = owner != NULL && owner != ptr ? *(U*)owner : U((T*)ptr); + } + static void deallocate(void* owner) { delete (U*)owner; } + operator T*() { + ptr = uniquePtr.get(); + if (owner == NULL || owner == ptr) { + owner = new U(UNIQUE_PTR_NAMESPACE::move(uniquePtr)); + } + return ptr; + } + operator const T*() { return uniquePtr.get(); } + operator U&() { return uniquePtr; } + operator U*() { return &uniquePtr; } + T* ptr; + size_t size; + void* owner; + U uniquePtr2; + U& uniquePtr; +}; +#endif + + + + +static void JavaCPP_my_test_00024Test_deallocate(void *p) { delete (::test::Test*)p; } +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; } +static void JavaCPP_my_test_00024Test_deallocateArray(void* p) { delete[] (::test::Test*)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[20][1] = { + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { "sizeof" }, + { NULL }, + { NULL }, + { NULL }, + { NULL }, + { NULL }, + { NULL }, + { "sizeof" }, + { NULL } }; + int offsets[20][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) }, + { -1 }, + { -1 }, + { -1 }, + { -1 }, + { -1 }, + { -1 }, + { sizeof(::test::Test) }, + { -1 } }; + int memberOffsetSizes[20] = { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; + jmethodID putMemberOffsetMID = JavaCPP_getStaticMethodID(env, 14, "putMemberOffset", "(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/Class;"); + if (putMemberOffsetMID == NULL) { + return JNI_ERR; + } + for (int i = 0; i < 20 && !env->ExceptionCheck(); i++) { + for (int j = 0; j < memberOffsetSizes[i] && !env->ExceptionCheck(); j++) { + if (env->PushLocalFrame(3) == 0) { + jvalue args[3]; + args[0].l = env->NewStringUTF(JavaCPP_classNames[i]); + args[1].l = members[i][j] == NULL ? NULL : env->NewStringUTF(members[i][j]); + args[2].i = offsets[i][j]; + jclass cls = (jclass)env->CallStaticObjectMethodA(JavaCPP_getClass(env, 14), putMemberOffsetMID, args); + if (cls == NULL || env->ExceptionCheck()) { + JavaCPP_log("Error putting member offsets for class %s.", JavaCPP_classNames[i]); + return JNI_ERR; + } + 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 JNI_ERR; + } + 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", "J"); + if (JavaCPP_positionFID == NULL) { + return JNI_ERR; + } + JavaCPP_limitFID = JavaCPP_getFieldID(env, 0, "limit", "J"); + if (JavaCPP_limitFID == NULL) { + return JNI_ERR; + } + JavaCPP_capacityFID = JavaCPP_getFieldID(env, 0, "capacity", "J"); + 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, 13, "ownerAddress", "J"); + if (JavaCPP_ownerAddressFID == NULL) { + return JNI_ERR; + } + JavaCPP_initMID = JavaCPP_getMethodID(env, 0, "init", "(JJJJ)V"); + if (JavaCPP_initMID == NULL) { + return JNI_ERR; + } + JavaCPP_arrayMID = JavaCPP_getMethodID(env, 15, "array", "()Ljava/lang/Object;"); + if (JavaCPP_arrayMID == NULL) { + return JNI_ERR; + } + JavaCPP_stringMID = JavaCPP_getMethodID(env, 12, "", "([B)V"); + if (JavaCPP_stringMID == NULL) { + return JNI_ERR; + } + JavaCPP_getBytesMID = JavaCPP_getMethodID(env, 12, "getBytes", "()[B"); + if (JavaCPP_getBytesMID == NULL) { + return JNI_ERR; + } + JavaCPP_toStringMID = JavaCPP_getMethodID(env, 16, "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 < 20; 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 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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jlong size = env->GetLongField(obj, JavaCPP_limitFID); + size -= position; + jobject rarg = NULL; + char* rptr; + rptr = ptr; + jlong rcapacity = size; + if (rptr != NULL) { + jlong rcapacityptr = rcapacity * sizeof(rptr[0]); + rarg = env->NewDirectByteBuffer((void*)rptr, rcapacityptr < INT_MAX ? rcapacityptr : INT_MAX); + } + return rarg; +} +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)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(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 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)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(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)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(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)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(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)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(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 jlong JNICALL Java_org_bytedeco_javacpp_Pointer_physicalBytes(JNIEnv* env, jclass cls) { + jlong rarg = 0; + jlong rvalue = JavaCPP_physicalBytes(); + rarg = (jlong)rvalue; + return rarg; +} +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; + jlong rcapacity = 1; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, NULL); +} + +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strerror(JNIEnv* env, jclass cls, jint arg0) { + jobject rarg = NULL; + char* rptr; + rptr = (char*)strerror(arg0); + if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strcat(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strcat((char*)ptr0, (char*)ptr1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strchr((char*)ptr0, arg1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strcmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jint rarg = 0; + int rvalue = strcmp((char*)ptr0, (char*)ptr1); + rarg = (jint)rvalue; + return rarg; +} +JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strcoll(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jint rarg = 0; + int rvalue = strcoll((char*)ptr0, (char*)ptr1); + rarg = (jint)rvalue; + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strcpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strcpy((char*)ptr0, (char*)ptr1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strcspn(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jlong rarg = 0; + size_t rvalue = (size_t)strcspn((char*)ptr0, (char*)ptr1); + rarg = (jlong)rvalue; + return rarg; +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strlen(JNIEnv* env, jclass cls, jobject arg0) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + jlong rarg = 0; + size_t rvalue = (size_t)strlen((char*)ptr0); + rarg = (jlong)rvalue; + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strncat(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strncat((char*)ptr0, (char*)ptr1, (size_t)arg2); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_BytePointer_strncmp(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jint rarg = 0; + int rvalue = strncmp((char*)ptr0, (char*)ptr1, (size_t)arg2); + rarg = (jint)rvalue; + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strncpy(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strncpy((char*)ptr0, (char*)ptr1, (size_t)arg2); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strpbrk(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strpbrk((char*)ptr0, (char*)ptr1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strrchr(JNIEnv* env, jclass cls, jobject arg0, jint arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strrchr((char*)ptr0, arg1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strspn(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jlong rarg = 0; + size_t rvalue = (size_t)strspn((char*)ptr0, (char*)ptr1); + rarg = (jlong)rvalue; + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strstr(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strstr((char*)ptr0, (char*)ptr1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_BytePointer_strtok(JNIEnv* env, jclass cls, jobject arg0, jobject arg1) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = NULL; + char* rptr; + rptr = (char*)strtok((char*)ptr0, (char*)ptr1); + if (rptr == (char*)ptr0) { + rarg = arg0; + } else if (rptr == (char*)ptr1) { + rarg = arg1; + } else if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + env->SetLongField(rarg, JavaCPP_addressFID, ptr_to_jlong(rptr)); + } + } + return rarg; +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_BytePointer_strxfrm(JNIEnv* env, jclass cls, jobject arg0, jobject arg1, jlong arg2) { + signed char* ptr0 = arg0 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg0, JavaCPP_addressFID)); + jlong position0 = arg0 == NULL ? 0 : env->GetLongField(arg0, JavaCPP_positionFID); + ptr0 += position0; + signed char* ptr1 = arg1 == NULL ? NULL : (signed char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jlong rarg = 0; + size_t rvalue = (size_t)strxfrm((char*)ptr0, (char*)ptr1, (size_t)arg2); + rarg = (jlong)rvalue; + return rarg; +} +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BytePointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + signed char* rptr = new (std::nothrow) signed char[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BytePointer_deallocateArray); +} +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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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__J(JNIEnv* env, jobject obj, jlong arg0) { + signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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__JB(JNIEnv* env, jobject obj, jlong arg0, jbyte arg1) { + signed char* ptr = (signed char*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = arg1; + 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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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 void JNICALL Java_org_bytedeco_javacpp_ShortPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + short* rptr = new (std::nothrow) short[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_ShortPointer_deallocateArray); +} +JNIEXPORT jshort JNICALL Java_org_bytedeco_javacpp_ShortPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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___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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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 jobject JNICALL Java_org_bytedeco_javacpp_ShortPointer_put__JS(JNIEnv* env, jobject obj, jlong arg0, jshort arg1) { + short* ptr = (short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0) { + int* rptr = new (std::nothrow) int[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_IntPointer_deallocateArray); +} +JNIEXPORT jint JNICALL Java_org_bytedeco_javacpp_IntPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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__JI(JNIEnv* env, jobject obj, jlong arg0, jint arg1) { + int* ptr = (int*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_LongPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + jlong* rptr = new (std::nothrow) jlong[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_LongPointer_deallocateArray); +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_LongPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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___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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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 jobject JNICALL Java_org_bytedeco_javacpp_LongPointer_put__JJ(JNIEnv* env, jobject obj, jlong arg0, jlong arg1) { + jlong* ptr = (jlong*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_FloatPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + float* rptr = new (std::nothrow) float[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_FloatPointer_deallocateArray); +} +JNIEXPORT jfloat JNICALL Java_org_bytedeco_javacpp_FloatPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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___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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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 jobject JNICALL Java_org_bytedeco_javacpp_FloatPointer_put__JF(JNIEnv* env, jobject obj, jlong arg0, jfloat arg1) { + float* ptr = (float*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_DoublePointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + double* rptr = new (std::nothrow) double[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_DoublePointer_deallocateArray); +} +JNIEXPORT jdouble JNICALL Java_org_bytedeco_javacpp_DoublePointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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___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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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 jobject JNICALL Java_org_bytedeco_javacpp_DoublePointer_put__JD(JNIEnv* env, jobject obj, jlong arg0, jdouble arg1) { + double* ptr = (double*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0) { + unsigned short* rptr = new (std::nothrow) unsigned short[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CharPointer_deallocateArray); +} +JNIEXPORT jchar JNICALL Java_org_bytedeco_javacpp_CharPointer_get__J(JNIEnv* env, jobject obj, jlong arg0) { + unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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__JC(JNIEnv* env, jobject obj, jlong arg0, jchar arg1) { + unsigned short* ptr = (unsigned short*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_PointerPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + void** rptr = new (std::nothrow) void*[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_PointerPointer_deallocateArray); +} +JNIEXPORT jobject JNICALL Java_org_bytedeco_javacpp_PointerPointer_get(JNIEnv* env, jobject obj, jclass arg0, jlong arg1) { + void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0, jobject arg1) { + void** ptr = (void**)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + char* ptr1 = arg1 == NULL ? NULL : (char*)jlong_to_ptr(env->GetLongField(arg1, JavaCPP_addressFID)); + jlong position1 = arg1 == NULL ? 0 : env->GetLongField(arg1, JavaCPP_positionFID); + ptr1 += position1; + jobject rarg = obj; + ptr[arg0] = ptr1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_BoolPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + bool* rptr = new (std::nothrow) bool[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_BoolPointer_deallocateArray); +} +JNIEXPORT jboolean JNICALL Java_org_bytedeco_javacpp_BoolPointer_get(JNIEnv* env, jobject obj, jlong arg0) { + bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0, jboolean arg1) { + bool* ptr = (bool*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = (bool)arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_CLongPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + long* rptr = new (std::nothrow) long[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_CLongPointer_deallocateArray); +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_CLongPointer_get(JNIEnv* env, jobject obj, jlong arg0) { + long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0, jlong arg1) { + long* ptr = (long*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = (long)arg1; + return rarg; +} + +JNIEXPORT void JNICALL Java_org_bytedeco_javacpp_SizeTPointer_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + size_t* rptr = new (std::nothrow) size_t[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_org_bytedeco_javacpp_SizeTPointer_deallocateArray); +} +JNIEXPORT jlong JNICALL Java_org_bytedeco_javacpp_SizeTPointer_get(JNIEnv* env, jobject obj, jlong arg0) { + size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(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, jlong arg0, jlong arg1) { + size_t* ptr = (size_t*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = obj; + ptr[arg0] = (size_t)arg1; + return rarg; +} + + +JNIEXPORT void JNICALL Java_my_test_00024Test_allocateArray(JNIEnv* env, jobject obj, jlong arg0) { + jthrowable exc = NULL; + try { + ::test::Test* rptr = new ::test::Test[arg0]; + jlong rcapacity = arg0; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_my_test_00024Test_deallocateArray); + } catch (...) { + exc = JavaCPP_handleException(env, 19); + } + + if (exc != NULL) { + env->Throw(exc); + } +} +JNIEXPORT jobject JNICALL Java_my_test_00024Test_test(JNIEnv* env, jobject obj) { + ::test::Test* ptr = (::test::Test*)jlong_to_ptr(env->GetLongField(obj, JavaCPP_addressFID)); + if (ptr == NULL) { + env->ThrowNew(JavaCPP_getClass(env, 17), "This pointer address is NULL."); + return 0; + } + jlong position = env->GetLongField(obj, JavaCPP_positionFID); + ptr += position; + jobject rarg = NULL; + signed char* rptr; + jthrowable exc = NULL; + try { + StringAdapter radapter(ptr->test()); + rptr = radapter; + jlong rcapacity = (jlong)radapter.size; + void* rowner = radapter.owner; + void (*deallocator)(void*) = &StringAdapter::deallocate; + if (rptr != NULL) { + rarg = JavaCPP_createPointer(env, 1); + if (rarg != NULL) { + JavaCPP_initPointer(env, rarg, rptr, rcapacity, rowner, deallocator); + } + } + } catch (...) { + exc = JavaCPP_handleException(env, 19); + } + + if (exc != NULL) { + env->Throw(exc); + } + return rarg; +} +JNIEXPORT void JNICALL Java_my_test_00024Test_allocate(JNIEnv* env, jobject obj) { + jthrowable exc = NULL; + try { + ::test::Test* rptr = new ::test::Test(); + jlong rcapacity = 1; + JavaCPP_initPointer(env, obj, rptr, rcapacity, rptr, &JavaCPP_my_test_00024Test_deallocate); + } catch (...) { + exc = JavaCPP_handleException(env, 19); + } + + if (exc != NULL) { + env->Throw(exc); + } +} + + +} + diff --git a/examples/src/main/java/my/Main.java b/examples/src/main/java/my/Main.java new file mode 100644 index 000000000..92a8c3e04 --- /dev/null +++ b/examples/src/main/java/my/Main.java @@ -0,0 +1,32 @@ +package my; + +import org.bytedeco.javacpp.BytePointer; +import org.bytedeco.javacpp.JavaCPP; + +import java.lang.reflect.Method; +import java.nio.file.Files; +import java.nio.file.Paths; +import java.util.List; + +public class Main { + public static void main(String[] args) throws Exception { + Class preset = my.presets.test.class; + + String java = "src/main/java"; + JavaCPP.generateJava(preset, java); + JavaCPP.compileJava(preset, java); + + String cpp = "src"; + JavaCPP.generateCpp(preset, cpp); + JavaCPP.compileCpp(preset, cpp, false); + + // In another method to delay loading the generated class + test(); + } + + public static void test() throws Exception { + BytePointer s = new my.test.Test().test(); + System.out.println(s.getString()); + } +} + diff --git a/examples/src/main/java/my/presets/test.java b/examples/src/main/java/my/presets/test.java new file mode 100644 index 000000000..b24d96097 --- /dev/null +++ b/examples/src/main/java/my/presets/test.java @@ -0,0 +1,22 @@ +package my.presets; + +import org.bytedeco.javacpp.annotation.Platform; +import org.bytedeco.javacpp.annotation.Properties; +import org.bytedeco.javacpp.caffe; +import org.bytedeco.javacpp.tools.InfoMap; +import org.bytedeco.javacpp.tools.InfoMapper; + +@Properties( + inherit = caffe.class, + target = "my.test", + value = { + @Platform( + includepath = {"include"}, + include= {"test.hpp"} + ) + } +) +public abstract class test implements InfoMapper { + public void map(InfoMap infoMap) { + } +} diff --git a/examples/src/main/java/my/test.java b/examples/src/main/java/my/test.java new file mode 100644 index 000000000..c9734f7f4 --- /dev/null +++ b/examples/src/main/java/my/test.java @@ -0,0 +1,50 @@ +// Targeted by JavaCPP version unknown: DO NOT EDIT THIS FILE + +package my; + +import java.nio.*; +import org.bytedeco.javacpp.*; +import org.bytedeco.javacpp.annotation.*; + +import static org.bytedeco.javacpp.opencv_core.*; +import static org.bytedeco.javacpp.opencv_imgproc.*; +import static org.bytedeco.javacpp.opencv_imgcodecs.*; +import static org.bytedeco.javacpp.opencv_videoio.*; +import static org.bytedeco.javacpp.opencv_highgui.*; +import static org.bytedeco.javacpp.caffe.*; + +// The following code has been generated by JavaCPP. + +public class test extends my.presets.test { + static { Loader.load(); } + +// Parsed from test.hpp + +// #ifndef TEST_HPP +// #define TEST_HPP + +// #include "caffe/caffe.hpp" + +@Namespace("test") public static class Test extends Pointer { + static { Loader.load(); } + /** Default native constructor. */ + public Test() { super((Pointer)null); allocate(); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public Test(long size) { super((Pointer)null); allocateArray(size); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public Test(Pointer p) { super(p); } + private native void allocate(); + private native void allocateArray(long size); + @Override public Test position(long position) { + return (Test)super.position(position); + } + + public native @StdString BytePointer test(); +} + + + +// #endif + + +} diff --git a/pom.xml b/pom.xml index 0a2780bda..044244197 100644 --- a/pom.xml +++ b/pom.xml @@ -94,6 +94,16 @@ 1.7.12 true + + org.jboss.shrinkwrap.resolver + shrinkwrap-resolver-api + 2.2.4 + + + org.jboss.shrinkwrap.resolver + shrinkwrap-resolver-impl-maven + 2.2.4 + diff --git a/src/main/java/org/bytedeco/javacpp/JavaCPP.java b/src/main/java/org/bytedeco/javacpp/JavaCPP.java new file mode 100644 index 000000000..724d155f9 --- /dev/null +++ b/src/main/java/org/bytedeco/javacpp/JavaCPP.java @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2011-2016 Samuel Audet + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.javacpp; + +import org.bytedeco.javacpp.tools.Runtime; + +public class JavaCPP { + public static void generateJava(Class preset, String dir) { + Runtime runtime = new Runtime(preset); + runtime.generateJava(dir); + } + + public static void compileJava(Class preset, String dir) { + Runtime runtime = new Runtime(preset); + runtime.compileJava(dir); + } + + public static void generateCpp(Class preset, String dir) { + Runtime runtime = new Runtime(preset); + runtime.generateCpp(dir); + } + + public static void compileCpp(Class preset, String dir, boolean debug) { + Runtime runtime = new Runtime(preset); + runtime.compileCpp(dir, debug); + } +} diff --git a/src/main/java/org/bytedeco/javacpp/Loader.java b/src/main/java/org/bytedeco/javacpp/Loader.java index 2eff3aab1..1a4a4c6ee 100644 --- a/src/main/java/org/bytedeco/javacpp/Loader.java +++ b/src/main/java/org/bytedeco/javacpp/Loader.java @@ -23,15 +23,22 @@ package org.bytedeco.javacpp; import java.io.File; +import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; +import java.net.JarURLConnection; import java.net.MalformedURLException; import java.net.URI; import java.net.URISyntaxException; import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; @@ -42,7 +49,9 @@ import java.util.WeakHashMap; import org.bytedeco.javacpp.annotation.Platform; import org.bytedeco.javacpp.tools.Builder; +import org.bytedeco.javacpp.tools.Coordinates; import org.bytedeco.javacpp.tools.Logger; +import org.bytedeco.javacpp.tools.Repository; /** * The Loader contains functionality to load native libraries, but also has a bit @@ -362,8 +371,8 @@ public static File extractResource(URL resourceURL, File directoryOrFile, /** User-specified cache directory set and returned by {@link #getCacheDir()}. */ static File cacheDir = null; - /** Temporary directory set and returned by {@link #getTempDir()}. */ - static File tempDir = null; + /** JavaCPP repository */ + static Repository repository = null; /** Contains all the native libraries that we have loaded to avoid reloading them. */ static Map loadedLibraries = Collections.synchronizedMap(new HashMap()); @@ -386,25 +395,19 @@ public static File getCacheDir() { } /** - * Creates a unique name for {@link #tempDir} out of - * {@code System.getProperty("java.io.tmpdir")} and {@code System.nanoTime()}. - * - * @return {@link #tempDir} + * Creates and returns the repository in which native libraries are stored. */ - public static File getTempDir() { - if (tempDir == null) { - File tmpdir = new File(System.getProperty("java.io.tmpdir")); - File f; - for (int i = 0; i < 1000; i++) { - f = new File(tmpdir, "javacpp" + System.nanoTime()); - if (f.mkdir()) { - tempDir = f; - tempDir.deleteOnExit(); - break; - } - } - } - return tempDir; + public static Repository getRepository() { + if (repository == null) { + Path root; + File cache = getCacheDir(); + if (cache != null) + root = cache.toPath(); + else + root = Paths.get(System.getProperty("user.home")); + repository = new Repository(root); + } + return repository; } /** Returns {@code System.getProperty("org.bytedeco.javacpp.loadlibraries")}. @@ -434,6 +437,16 @@ public static String load(boolean pathsFirst) { public static String load(Class cls) { return load(cls, loadProperties(), false); } + public static Coordinates coordinates(Class cls) { + if (cls.isAnnotationPresent(org.bytedeco.javacpp.annotation.Coordinates.class)) { + org.bytedeco.javacpp.annotation.Coordinates c = + (org.bytedeco.javacpp.annotation.Coordinates) + cls.getAnnotation(org.bytedeco.javacpp.annotation.Coordinates.class); + return new Coordinates(c.group(), c.id(), c.version()); + } + return null; + } + /** * Loads native libraries associated with the given {@link Class}. * @@ -444,8 +457,8 @@ public static String load(Class cls) { * (but {@code if (!isLoadLibraries() || cls == null) { return null; }}) * @throws NoClassDefFoundError on Class initialization failure * @throws UnsatisfiedLinkError on native library loading failure - * @see #findLibrary(Class, ClassProperties, String, boolean) - * @see #loadLibrary(URL[], String) + * @see #findLibrary(Class, ClassProperties, String, boolean, Coordinates) + * @see #loadLibrary(URL[], String, Coordinates) */ public static String load(Class cls, Properties properties, boolean pathsFirst) { if (!isLoadLibraries() || cls == null) { @@ -456,6 +469,9 @@ public static String load(Class cls, Properties properties, boolean pathsFirst) cls = getEnclosingClass(cls); ClassProperties p = loadProperties(cls, properties, true); + // Get library coordinates if available + Coordinates coordinates = coordinates(cls); + // Force initialization of all the target classes in case they need it List targets = p.get("target"); if (targets.isEmpty()) { @@ -489,8 +505,8 @@ public static String load(Class cls, Properties properties, boolean pathsFirst) UnsatisfiedLinkError preloadError = null; for (String preload : preloads) { try { - URL[] urls = findLibrary(cls, p, preload, pathsFirst); - loadLibrary(urls, preload); + URL[] urls = findLibrary(cls, p, preload, pathsFirst, coordinates); + loadLibrary(urls, preload, coordinates); } catch (UnsatisfiedLinkError e) { preloadError = e; } @@ -498,8 +514,8 @@ public static String load(Class cls, Properties properties, boolean pathsFirst) try { String library = p.getProperty("platform.library"); - URL[] urls = findLibrary(cls, p, library, pathsFirst); - return loadLibrary(urls, library); + URL[] urls = findLibrary(cls, p, library, pathsFirst, coordinates); + return loadLibrary(urls, library, coordinates); } catch (UnsatisfiedLinkError e) { if (preloadError != null && e.getCause() == null) { e.initCause(preloadError); @@ -520,9 +536,11 @@ public static String load(Class cls, Properties properties, boolean pathsFirst) * @param libnameversion the name of the library + "@" + optional version tag * + "#" + a second optional name used at extraction (or empty to prevent it) * @param pathsFirst search the paths first before bundled resources + * @param coordinates maven coordinates * @return URLs that point to potential locations of the library */ - public static URL[] findLibrary(Class cls, ClassProperties properties, String libnameversion, boolean pathsFirst) { + public static URL[] findLibrary(Class cls, ClassProperties properties, String libnameversion, + boolean pathsFirst, Coordinates coordinates) { if (libnameversion.trim().endsWith("#")) { return new URL[0]; } @@ -630,7 +648,7 @@ public static URL[] findLibrary(Class cls, ClassProperties properties, String li * (but {@code if (!isLoadLibraries) { return null; }}) * @throws UnsatisfiedLinkError on failure */ - public static String loadLibrary(URL[] urls, String libnameversion) { + public static String loadLibrary(URL[] urls, String libnameversion, Coordinates coordinates) { if (!isLoadLibraries()) { return null; } @@ -641,7 +659,6 @@ public static String loadLibrary(URL[] urls, String libnameversion) { return filename; } - File tempFile = null; UnsatisfiedLinkError loadError = null; try { for (URL url : urls) { @@ -675,46 +692,39 @@ public static String loadLibrary(URL[] urls, String libnameversion) { // ... get the URL fragment to let users rename library files ... name = url.getRef(); } - // ... then check if it has not already been extracted, and if not ... - file = new File(getCacheDir() != null ? getCacheDir() : getTempDir(), name); - if (!file.exists()) { - if (tempFile != null && tempFile.exists()) { - tempFile.deleteOnExit(); - } - // ... then extract it from our resources ... - if (logger.isDebugEnabled()) { - logger.debug("Extracting " + url); - } - extractResource(url, file, null, null); - if (getCacheDir() == null) { - tempFile = file; - } - } else while (System.currentTimeMillis() - file.lastModified() < 1000) { - // ... else wait until the file is at least 1 second old ... - try { - Thread.sleep(1000); - } catch (InterruptedException ex) { - // ... reset interrupt to be nice ... - Thread.currentThread().interrupt(); - } + + // ... then get it from repo ... + + JarURLConnection c = (JarURLConnection) url.openConnection(); + Path jar = Paths.get(c.getJarFileURL().getFile()); + + // For legacy jars without coordinates + if (coordinates == null) + coordinates = new Coordinates( + "legacy", + jar.getFileName().toString(), + Long.toString(Files.size(jar)) + "-" + + Long.toString(jar.toFile().lastModified())); + + Path repo = getRepository().getPath( + new Coordinates(coordinates, getPlatform(), jar)); + file = new File(repo.toFile(), name); } - } - if (file != null && file.exists()) { - filename = file.getAbsolutePath(); - try { - // ... and load it! - if (logger.isDebugEnabled()) { - logger.debug("Loading " + filename); - } - loadedLibraries.put(libnameversion, filename); - System.load(filename); - return filename; - } catch (UnsatisfiedLinkError e) { - loadError = e; - loadedLibraries.remove(libnameversion); - if (logger.isDebugEnabled()) { - logger.debug("Failed to load " + filename + ": " + e); - } + + filename = file.getAbsolutePath(); + try { + // ... and load it! + if (logger.isDebugEnabled()) { + logger.debug("Loading " + filename); + } + loadedLibraries.put(libnameversion, filename); + System.load(filename); + return filename; + } catch (UnsatisfiedLinkError e) { + loadError = e; + loadedLibraries.remove(libnameversion); + if (logger.isDebugEnabled()) { + logger.debug("Failed to load " + filename + ": " + e); } } } @@ -746,59 +756,9 @@ public static String loadLibrary(URL[] urls, String libnameversion) { logger.debug("Failed to extract for " + libnameversion + ": " + e); } throw e; - } finally { - if (tempFile != null && tempFile.exists()) { - tempFile.deleteOnExit(); - } - // But under Windows, it won't get deleted! } } - // So, let's use a shutdown hook... - static { - if (getPlatform().startsWith("windows")) { - Runtime.getRuntime().addShutdownHook(new Thread() { - @Override public void run() { - if (tempDir == null) { - return; - } - try { - // ... to launch a separate process ... - List command = new ArrayList(); - command.add(System.getProperty("java.home") + "/bin/java"); - command.add("-classpath"); - command.add((new File(Loader.class.getProtectionDomain().getCodeSource().getLocation().toURI())).toString()); - command.add(Loader.class.getName()); - command.add(tempDir.getAbsolutePath()); - new ProcessBuilder(command).start(); - } catch (IOException e) { - throw new RuntimeException(e); - } catch (URISyntaxException e) { - throw new RuntimeException(e); - } - } - }); - } - } - - // ... that makes sure to delete all our files. - public static void main(String[] args) throws InterruptedException { - File tmpdir = new File(System.getProperty("java.io.tmpdir")); - File tempDir = new File(args[0]); - if (!tmpdir.equals(tempDir.getParentFile()) || - !tempDir.getName().startsWith("javacpp")) { - // Someone is trying to break us ... ? - return; - } - for (File file : tempDir.listFiles()) { - while (file.exists() && !file.delete()) { - Thread.sleep(100); - } - } - tempDir.delete(); - } - - /** * Contains {@code offsetof()} and {@code sizeof()} values of native types * of {@code struct}, {@code class}, and {@code union}. A {@link WeakHashMap} diff --git a/src/main/java/org/bytedeco/javacpp/annotation/Coordinates.java b/src/main/java/org/bytedeco/javacpp/annotation/Coordinates.java new file mode 100644 index 000000000..74b33abe0 --- /dev/null +++ b/src/main/java/org/bytedeco/javacpp/annotation/Coordinates.java @@ -0,0 +1,37 @@ +/* + * Copyright (C) 2014-2016 Samuel Audet + * + * Licensed either under the Apache License, Version 2.0, or (at your option) + * under the terms of the GNU General Public License as published by + * the Free Software Foundation (subject to the "Classpath" exception), + * either version 2, or any later version (collectively, the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * http://www.gnu.org/licenses/ + * http://www.gnu.org/software/classpath/license.html + * + * or as provided in the LICENSE.txt file that accompanied this code. + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.bytedeco.javacpp.annotation; + +import java.lang.annotation.*; + +/** + * Uniquely identifies a library in Maven and the local JavaCPP repository. + */ +@Documented +@Retention(RetentionPolicy.RUNTIME) +@Target({ElementType.TYPE}) +public @interface Coordinates { + String group(); + String id(); + String version(); +} \ No newline at end of file diff --git a/src/main/java/org/bytedeco/javacpp/tools/BuildMojo.java b/src/main/java/org/bytedeco/javacpp/tools/BuildMojo.java index b562d0bfa..8ea4afe2a 100644 --- a/src/main/java/org/bytedeco/javacpp/tools/BuildMojo.java +++ b/src/main/java/org/bytedeco/javacpp/tools/BuildMojo.java @@ -194,8 +194,15 @@ String[] merge(String[] ss, String s) { @Override public void warn (String s) { log.warn(s); } @Override public void error(String s) { log.error(s); } }; + + Coordinates coordinates = new Coordinates( + project.getGroupId(), + project.getArtifactId(), + project.getVersion() + ); Builder builder = new Builder(logger) .classPaths(classPaths) + .includePath(includePath) .outputDirectory(outputDirectory) .outputName(outputName) .compile(compile) @@ -208,10 +215,12 @@ String[] merge(String[] ss, String s) { .properties(propertyKeysAndValues) .classesOrPackages(classOrPackageNames) .environmentVariables(environmentVariables) - .compilerOptions(compilerOptions); + .compilerOptions(compilerOptions) + .coordinates(coordinates); Properties properties = builder.properties; log.info("Detected platform \"" + Loader.getPlatform() + "\""); log.info("Building for platform \"" + properties.get("platform") + "\""); + log.info("Coordinates for builder: " + coordinates.canonical()); String separator = properties.getProperty("platform.path.separator"); for (String s : merge(includePaths, includePath)) { String v = properties.getProperty("platform.includepath", ""); diff --git a/src/main/java/org/bytedeco/javacpp/tools/Builder.java b/src/main/java/org/bytedeco/javacpp/tools/Builder.java index 2f5a2c54a..2c943e93e 100644 --- a/src/main/java/org/bytedeco/javacpp/tools/Builder.java +++ b/src/main/java/org/bytedeco/javacpp/tools/Builder.java @@ -31,6 +31,14 @@ import java.net.URI; import java.net.URISyntaxException; import java.net.URL; +import java.nio.file.FileVisitResult; +import java.nio.file.Files; +import java.nio.file.LinkOption; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.SimpleFileVisitor; +import java.nio.file.StandardCopyOption; +import java.nio.file.attribute.BasicFileAttributes; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -56,7 +64,8 @@ public class Builder { /** - * Calls {@link Parser#parse(File, String[], Class)} after creating an instance of the Class. + * Calls {@link Parser#parse(File, String[], Class, Coordinates)} after creating an + * instance of the Class. * * @param classPath an array of paths to try to load header files from * @param cls The class annotated with {@link org.bytedeco.javacpp.annotation.Properties} @@ -66,7 +75,7 @@ public class Builder { * @throws ParserException on C/C++ header file parsing error */ File parse(String[] classPath, Class cls) throws IOException, ParserException { - return new Parser(logger, properties).parse(outputDirectory, classPath, cls); + return new Parser(logger, properties).parse(outputDirectory, classPath, cls, coordinates); } /** @@ -479,6 +488,8 @@ public Builder(Logger logger) { /** Logger where to send debug, info, warning, and error messages. */ final Logger logger; + /** Include file directory for this library. */ + String includePath; /** The directory where the generated files and compiled shared libraries get written to. * By default they are placed in the same directory as the {@code .class} file. */ File outputDirectory = null; @@ -503,6 +514,8 @@ public Builder(Logger logger) { Map environmentVariables = null; /** Contains additional command line options from the user for the native compiler. */ Collection compilerOptions = null; + /** Coordinates of the library. */ + Coordinates coordinates = null; /** Splits argument with {@link File#pathSeparator} and appends result to paths of the {@link #classScanner}. */ public Builder classPaths(String classPaths) { @@ -514,6 +527,11 @@ public Builder classPaths(String ... classPaths) { classScanner.getClassLoader().addPaths(classPaths); return this; } + /** Sets the {@link #includePath} field to the argument. */ + public Builder includePath(String includePath) { + this.includePath = includePath; + return this; + } /** Sets the {@link #outputDirectory} field to the argument. */ public Builder outputDirectory(String outputDirectory) { outputDirectory(outputDirectory == null ? null : new File(outputDirectory)); @@ -629,6 +647,11 @@ public Builder compilerOptions(String ... options) { } return this; } + /** Sets the library coordinates. */ + public Builder coordinates(Coordinates coordinates) { + this.coordinates = coordinates; + return this; + } /** * Starts the build process and returns an array of {@link File} produced. @@ -687,30 +710,54 @@ public File[] build() throws IOException, InterruptedException, ParserException // ... but we should use all the inherited paths! p = Loader.loadProperties(classArray, properties, true); - File directory = f.getParentFile(); + final Path directory = f.toPath().getParent(); for (String s : preloads) { - URL[] urls = Loader.findLibrary(null, p, s, true); - File fi; + URL[] urls = Loader.findLibrary(null, p, s, true, coordinates); + logger.info("URLs for " + s + ": " + Arrays.toString(urls)); + final Path fi; try { - fi = new File(urls[0].toURI()); + fi = resolveLink(Paths.get(urls[0].toURI())); } catch (Exception e) { continue; } - File fo = new File(directory, fi.getName()); - if (fi.exists() && !outputFiles.contains(fo)) { - logger.info("Copying " + fi); - FileInputStream fis = new FileInputStream(fi); - FileOutputStream fos = new FileOutputStream(fo); - byte[] buffer = new byte[1024]; - int length; - while ((length = fis.read(buffer)) != -1) { - fos.write(buffer, 0, length); + // Copy the library and links pointing to it + Files.walkFileTree(fi.getParent(), new SimpleFileVisitor() { + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) + throws IOException { + Path lib = resolveLink(file); + if (lib.getFileName().equals(fi.getFileName())) { + Path dst = directory.resolve(file.getFileName()); + logger.info("Copying " + file + " to " + dst); + Files.copy(file, dst, + StandardCopyOption.REPLACE_EXISTING, + LinkOption.NOFOLLOW_LINKS); + } + return FileVisitResult.CONTINUE; } - fos.close(); - fis.close(); - outputFiles.add(fo); - } + }); } + // Copy include files to target for packaging + final Path src = Paths.get(includePath); + final Path dst = directory.getParent().resolve("include"); + Files.walkFileTree(src, new SimpleFileVisitor() { + @Override + public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException { + Path rel = src.relativize(dir); + rel = dst.resolve(rel.toString()); + if (!Files.exists(rel)) + Files.createDirectories(rel); + return FileVisitResult.CONTINUE; + } + + @Override + public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { + Path rel = src.relativize(file); + rel = dst.resolve(rel.toString()); + Files.copy(file, rel, StandardCopyOption.REPLACE_EXISTING); + return FileVisitResult.CONTINUE; + } + }); } } } @@ -730,6 +777,12 @@ public File[] build() throws IOException, InterruptedException, ParserException return files; } + private static Path resolveLink(Path path) throws IOException { + while(Files.isSymbolicLink(path)) + path = path.getParent().resolve(Files.readSymbolicLink(path)); + return path; + } + /** * Simply prints out to the display the command line usage. */ @@ -757,6 +810,7 @@ public static void printHelp() { System.out.println(" -jarprefix Also create a JAR file named \"-.jar\""); System.out.println(" -properties Load all properties from resource"); System.out.println(" -propertyfile Load all properties from file"); + System.out.println(" -coordinates Library identifier (group:id:version)."); System.out.println(" -D= Set property to value"); System.out.println(" -Xcompiler