自学教程：C++ throwRuntimeException函数代码示例

JNIEXPORT void JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZ_l2Send  (JNIEnv* env, jobject peer, jlong handle, jbyteArray data, jint transmitMTU) {#ifdef BLUECOVE_L2CAP_MTU_TRUNCATE    struct l2cap_options opt;    if (!l2Get_options(env, handle, &opt)) {        return;    }#endif //BLUECOVE_L2CAP_MTU_TRUNCATE    if (data == NULL) {        throwRuntimeException(env, "Invalid argument");        return;    }    jbyte *bytes = (*env)->GetByteArrayElements(env, data, 0);    if (bytes == NULL) {        throwRuntimeException(env, "Invalid argument");        return;    }    int len = (int)(*env)->GetArrayLength(env, data);    if (len > transmitMTU) {		len = transmitMTU;	}#ifdef BLUECOVE_L2CAP_MTU_TRUNCATE    if (len > opt.omtu) {        len = opt.omtu;    }#endif //BLUECOVE_L2CAP_MTU_TRUNCATE    int count = send(handle, (char *)bytes, len, 0);    if (count < 0) {        throwIOException(env, "Failed to write. [%d] %s", errno, strerror(errno));    }    (*env)->ReleaseByteArrayElements(env, data, bytes, 0);}

JNIEXPORT void JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZDBus_connectionRfWrite__J_3BII  (JNIEnv* env, jobject peer, jlong handle, jbyteArray b, jint off, jint len) {    if (b == NULL) {        throwRuntimeException(env, "Invalid argument");        return;    }    jbyte *bytes = (*env)->GetByteArrayElements(env, b, 0);    if (bytes == NULL) {        throwRuntimeException(env, "Invalid argument");        return;    }    int done = 0;    while(done < len) {        int count = send(handle, (char *)(bytes + off + done), len - done, 0);        if (count < 0) {            throwIOException(env, "Failed to write. [%d] %s", errno, strerror(errno));            break;        }        if (isCurrentThreadInterrupted(env, peer)) {            break;        }        done += count;    }    (*env)->ReleaseByteArrayElements(env, b, bytes, 0);}

bool DeviceInquiryCallback_builDeviceInquiryCallbacks(JNIEnv * env, struct DeviceInquiryCallback* callback, jobject inquiryRunnable, jobject startedNotify) {    jclass inquiryRunnableClass = (*env)->GetObjectClass(env, inquiryRunnable);    if (inquiryRunnableClass == NULL) {        throwRuntimeException(env, "Fail to get Object Class");        return false;    }    jmethodID deviceDiscoveredCallbackMethod = (*env)->GetMethodID(env, inquiryRunnableClass, "deviceDiscoveredCallback", "(Ljavax/bluetooth/DiscoveryListener;JILjava/lang/String;Z)V");    if (deviceDiscoveredCallbackMethod == NULL) {        throwRuntimeException(env, "Fail to get MethodID deviceDiscoveredCallback");        return false;    }    jclass notifyClass = (*env)->GetObjectClass(env, startedNotify);    if (notifyClass == NULL) {        throwRuntimeException(env, "Fail to get Object Class");        return false;    }    jmethodID notifyMethod = (*env)->GetMethodID(env, notifyClass, "deviceInquiryStartedCallback", "()V");    if (notifyMethod == NULL) {        throwRuntimeException(env, "Fail to get MethodID deviceInquiryStartedCallback");        return false;    }    callback->inquiryRunnable = inquiryRunnable;    callback->deviceDiscoveredCallbackMethod = deviceDiscoveredCallbackMethod;    callback->startedNotify = startedNotify;    callback->startedNotifyNotifyMethod = notifyMethod;    return true;}

static void setText(JNIEnv* env, jclass clazz, RegExData* data, jstring text){    UErrorCode status = U_ZERO_ERROR;    uregex_setText(data->regex, &EMPTY_STRING, 0, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);        return;    }    if (data->text != &EMPTY_STRING) {        delete[] data->text;        data->text = NULL;    }    int textLen = env->GetStringLength(text);    if (textLen == 0) {        data->text = &EMPTY_STRING;    } else {        data->text = new jchar[textLen + 1];        env->GetStringRegion(text, 0, textLen, data->text);        data->text[textLen] = 0;    }    uregex_setText(data->regex, data->text, textLen, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }}

JNIEXPORT jstring JNICALL Java_com_intel_bluetooth_BluetoothStackBlueZ_getRemoteDeviceVersionInfoImpl(JNIEnv *env, jobject peer, jint deviceDescriptor, jlong remoteDeviceAddressLong) {    struct hci_conn_info_req *conn_info;    struct hci_version ver;    char info[256];    conn_info = (struct hci_conn_info_req*)malloc(sizeof(*conn_info) + sizeof(struct hci_conn_info));    if (!conn_info) {        throwRuntimeException(env, cOUT_OF_MEMORY);        return NULL;    }    memset(conn_info, 0, sizeof(struct hci_conn_info));    longToDeviceAddr(remoteDeviceAddressLong, &(conn_info->bdaddr));    conn_info->type = ACL_LINK;    if (ioctl((int)deviceDescriptor, HCIGETCONNINFO, (unsigned long) conn_info) < 0) {        free(conn_info);        throwRuntimeException(env, "Fail to get connection info");        return NULL;    }    int error = hci_read_remote_version((int)deviceDescriptor, conn_info->conn_info->handle, &ver, READ_REMOTE_NAME_TIMEOUT);    if (error < 0) {        throwRuntimeException(env, "Can not get remote device info");        free(conn_info);        return NULL;    }    snprintf(info, 256, "manufacturer=%i,lmp_version=%i,lmp_sub_version=%i", ver.manufacturer, ver.lmp_ver, ver.lmp_subver);    free(conn_info);    return (*env)->NewStringUTF(env, info);}

inline void convertException(JNIEnv* env, Func func) noexcept{    try {        func();    } catch (JavaException& e) {        return;    } catch (std::exception& e) {        throwRuntimeException(env, e.what());    } catch (...) {        throwRuntimeException(env, "Unindentified exception thrown (not derived from std::exception)");    }}

jmethodID getGetMethodID(JNIEnv * env, jclass clazz, const char *name, const char *sig) {    if (clazz == NULL) {        throwRuntimeException(env, "Fail to get MethodID %s for NULL class", name);        return NULL;    }    jmethodID methodID = (*env)->GetMethodID(env, clazz, name, sig);    if (methodID == NULL) {        throwRuntimeException(env, "Fail to get MethodID %s", name);        return NULL;    }    return methodID;}

jint epollCtl(JNIEnv * env, jint efd, int op, jint fd, jint flags, jint id) {    uint32_t events = EPOLLET;    if (flags & EPOLL_ACCEPT) {        events |= EPOLLIN;    }    if (flags & EPOLL_READ) {        events |= EPOLLIN | EPOLLRDHUP;    }    if (flags & EPOLL_WRITE) {        events |= EPOLLOUT;    }    struct epoll_event ev = {        .events = events,        // encode the id into the events        .data.u64 = (((uint64_t) id) << 32L)    };    return epoll_ctl(efd, op, fd, &ev);}jint getOption(JNIEnv *env, jint fd, int level, int optname, const void *optval, socklen_t optlen) {    int code;    code = getsockopt(fd, level, optname, optval, &optlen);    if (code == 0) {        return 0;    }    int err = errno;    throwRuntimeException(env, exceptionMessage("Error during getsockopt(...): ", err));    return code;}

static inline struct io_control * getIOControl(JNIEnv* env, jobject pointer) {    struct io_control * ioControl = (struct io_control *) (*env)->GetDirectBufferAddress(env, pointer);    if (ioControl == NULL) {       throwRuntimeException(env, "Controller not initialized");    }    return ioControl;}

/** * private static native int EVP_PKEY_new_RSA(byte[] n, byte[] e, byte[] d, byte[] p, byte[] q); */static EVP_PKEY* NativeCrypto_EVP_PKEY_new_RSA(JNIEnv* env, jclass clazz, jbyteArray n, jbyteArray e, jbyteArray d, jbyteArray p, jbyteArray q) {    // LOGD("Entering EVP_PKEY_new_RSA()");    RSA* rsa = RSA_new();    rsa->n = arrayToBignum(env, n);    rsa->e = arrayToBignum(env, e);    if (d != NULL) {        rsa->d = arrayToBignum(env, d);    }    if (p != NULL) {        rsa->p = arrayToBignum(env, p);    }    if (q != NULL) {        rsa->q = arrayToBignum(env, q);    }    // int check = RSA_check_key(rsa);    // LOGI("RSA_check_key returns %d", check);    if (rsa->n == NULL || rsa->e == NULL) {        RSA_free(rsa);        throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");        return NULL;    }    EVP_PKEY* pkey = EVP_PKEY_new();    EVP_PKEY_assign_RSA(pkey, rsa);    return pkey;}

/** * private static native int EVP_PKEY_new_DSA(byte[] p, byte[] q, byte[] g, byte[] pub_key, byte[] priv_key); */static EVP_PKEY* NativeCrypto_EVP_PKEY_new_DSA(JNIEnv* env, jclass clazz, jbyteArray p, jbyteArray q, jbyteArray g, jbyteArray pub_key, jbyteArray priv_key) {    // LOGD("Entering EVP_PKEY_new_DSA()");    DSA* dsa = DSA_new();    dsa->p = arrayToBignum(env, p);    dsa->q = arrayToBignum(env, q);    dsa->g = arrayToBignum(env, g);    dsa->pub_key = arrayToBignum(env, pub_key);    if (priv_key != NULL) {        dsa->priv_key = arrayToBignum(env, priv_key);    }    if (dsa->p == NULL || dsa->q == NULL || dsa->g == NULL || dsa->pub_key == NULL) {        DSA_free(dsa);        throwRuntimeException(env, "Unable to convert BigInteger to BIGNUM");        return NULL;    }    EVP_PKEY* pkey = EVP_PKEY_new();    EVP_PKEY_assign_DSA(pkey, dsa);    return pkey;}

bool threadSleep(JNIEnv *env, jlong millis) {    jclass clazz = (*env)->FindClass(env, "java/lang/Thread");    if (clazz == NULL) {        throwRuntimeException(env, "Fail to get Thread class");        return false;    }    jmethodID methodID = (*env)->GetStaticMethodID(env, clazz, "sleep", "(J)V");    if (methodID == NULL) {        throwRuntimeException(env, "Fail to get MethodID Thread.sleep");        return false;    }    (*env)->CallStaticVoidMethod(env, clazz, methodID, millis);    if ((*env)->ExceptionCheck(env)) {        return false;    }    return true;}

JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_epollCreate(JNIEnv * env, jclass clazz) {    jint efd = epoll_create1(EPOLL_CLOEXEC);    if (efd < 0) {        int err = errno;        throwRuntimeException(env, exceptionMessage("Error during epoll_create(...): ", err));    }    return efd;}

static void reset(JNIEnv* env, jclass clazz, RegExData* data, jint position){    UErrorCode status = U_ZERO_ERROR;    uregex_reset(data->regex, position, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }}

int setOption(JNIEnv *env, jint fd, int level, int optname, const void *optval, socklen_t len) {    int rc = setsockopt(fd, level, optname, optval, len);    if (rc < 0) {        int err = errno;        throwRuntimeException(env, exceptionMessage("Error during setsockopt(...): ", err));    }    return rc;}

JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_read(JNIEnv * env, jclass clazz, jint fd, jobject jbuffer, jint pos, jint limit) {    void *buffer = (*env)->GetDirectBufferAddress(env, jbuffer);    if (buffer == NULL) {        throwRuntimeException(env, "Unable to access address of buffer");        return -1;    }    return read0(env, clazz, fd, buffer, pos, limit);}

bool isCurrentThreadInterrupted(JNIEnv *env, jobject peer) {    jclass peerClass = (*env)->GetObjectClass(env, peer);    if (peerClass == NULL) {        throwRuntimeException(env, "Fail to get Object Class");        return true;    }    jmethodID aMethod = (*env)->GetMethodID(env, peerClass, "isCurrentThreadInterruptedCallback", "()Z");    if (aMethod == NULL) {        throwRuntimeException(env, "Fail to get MethodID isCurrentThreadInterruptedCallback");        return true;    }    if ((*env)->CallBooleanMethod(env, peer, aMethod)) {        throwInterruptedIOException(env, "thread interrupted");        return true;    }    return (*env)->ExceptionCheck(env);}

/* * Creates compatible GraphicsInfo structure for specified device context */static inline GraphicsInfo *createCompatibleImageInfo(JNIEnv *env, HDC hdc, jint width, jint height) {    GraphicsInfo *gi = (GraphicsInfo *) malloc(sizeof(GraphicsInfo));       // To avoid issue of joint operation Windows NetMeeting and GL,       // we create HDC and Bitmap for Volatile Image which will compatible        // HDC of the entire screen. It may leads to other issues on        // multimonitor systems in the future.        gi->hwnd = 0;       HDC dc = GetDC(NULL);    //gi->hdc = CreateCompatibleDC(hdc);    gi->hdc = CreateCompatibleDC(dc);    if (gi->hdc == NULL) {        // We are out of GDI resources        runGC(env);        //gi->hdc = CreateCompatibleDC(hdc);        gi->hdc = CreateCompatibleDC(dc);        if (gi->hdc == NULL)            throwRuntimeException(env);    }                // Creating bitmap and setting it to DC    //gi->bmp = CreateCompatibleBitmap(hdc, width, height);    gi->bmp = CreateCompatibleBitmap(dc, width, height);    if (gi->bmp == NULL) {        // We are out of GDI resources        runGC(env);        //gi->bmp = CreateCompatibleBitmap(hdc, width, height);        gi->bmp = CreateCompatibleBitmap(dc, width, height);        if (gi->bmp == NULL)            throwRuntimeException(env);    }    SelectObject(gi->hdc, gi->bmp);       ReleaseDC(NULL, dc);        gi->graphics = new Graphics(gi->hdc);    gi->pen = 0;    gi->brush = 0;       gi->matrix = 0;    gi->clip = new Region(Rect(0, 0, width, height));    gi->graphics->SetClip(gi->clip);        return gi; }

JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_epollCtlDel(JNIEnv * env, jclass clazz, jint efd, jint fd) {    // Create an empty event to workaround a bug in older kernels which can not handle NULL.    struct epoll_event event = { 0 };    if (epoll_ctl(efd, EPOLL_CTL_DEL, fd, &event) < 0) {        int err = errno;        throwRuntimeException(env, exceptionMessage("Error during calling epoll_ctl(...): ", err));    }}

JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_sendTo(JNIEnv * env, jclass clazz, jint fd, jobject jbuffer, jint pos, jint limit, jbyteArray address, jint scopeId, jint port) {    void *buffer = (*env)->GetDirectBufferAddress(env, jbuffer);    if (buffer == NULL) {        throwRuntimeException(env, "Unable to access address of buffer");        return -1;    }    return sendTo0(env, fd, buffer, pos, limit, address, scopeId, port);}

JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_eventFdRead(JNIEnv * env, jclass clazz, jint fd) {    uint64_t eventfd_t;    if (eventfd_read(fd, &eventfd_t) != 0) {        // something is serious wrong        throwRuntimeException(env, "Error calling eventfd_read(...)");    }}

JNIEXPORT void JNICALL Java_io_netty_channel_epoll_Native_eventFdWrite(JNIEnv * env, jclass clazz, jint fd, jlong value) {    jint eventFD = eventfd_write(fd, (eventfd_t)value);    if (eventFD < 0) {        int err = errno;        throwRuntimeException(env, exceptionMessage("Error calling eventfd_write(...): ", err));    }}

static void setRegion(JNIEnv* env, jclass clazz, RegExData* data, jint start,                      jint end){    UErrorCode status = U_ZERO_ERROR;    uregex_setRegion(data->regex, start, end, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }}

static jint regionStart(JNIEnv* env, jclass clazz, RegExData* data){    UErrorCode status = U_ZERO_ERROR;    int result = uregex_regionStart(data->regex, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }    return result;}

static void useAnchoringBounds(JNIEnv* env, jclass clazz, RegExData* data,                               jboolean value){    UErrorCode status = U_ZERO_ERROR;    uregex_useAnchoringBounds(data->regex, value, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }}

JNIEXPORT jint JNICALL Java_io_netty_channel_epoll_Native_eventFd(JNIEnv * env, jclass clazz) {    jint eventFD =  eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);    if (eventFD < 0) {        int err = errno;        throwRuntimeException(env, exceptionMessage("Error creating eventFD(...): ", err));    }    return eventFD;}

static jboolean requireEnd(JNIEnv* env, jclass clazz, RegExData* data){    UErrorCode status = U_ZERO_ERROR;    jboolean result = uregex_requireEnd(data->regex, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }    return result;}

JNIEXPORT void JNICALL Java_org_apache_activemq_artemis_jlibaio_LibaioContext_freeBuffer  (JNIEnv * env, jclass clazz, jobject jbuffer) {    if (jbuffer == NULL)    {       throwRuntimeException(env, "Null pointer");       return;    }  	void *  buffer = (*env)->GetDirectBufferAddress(env, jbuffer);  	free(buffer);}

JNIEXPORT jstring JNICALL Java_io_netty_channel_epoll_Native_kernelVersion(JNIEnv *env, jclass clazz) {    struct utsname name;    int res = uname(&name);    if (res == 0) {        return (*env)->NewStringUTF(env, name.release);    }    int err = errno;    throwRuntimeException(env, exceptionMessage("Error during uname(...): ", err));    return NULL;}

static jboolean lookingAt(JNIEnv* env, jclass clazz, RegExData* data,                          jint startIndex){    UErrorCode status = U_ZERO_ERROR;    jboolean result = uregex_lookingAt(data->regex, startIndex, &status);    if (!U_SUCCESS(status)) {        throwRuntimeException(env, status);    }    return result;}