Please, help us to better serve our user community by answering the following short survey: https://www.hdfgroup.org/website-survey/

| HDF 4.3.0 API Reference |

Loading...
Searching...
No Matches
Macros | Functions
h4jni.h File Reference
`#include <string.h>`
`#include <jni.h>`

## Macros
#define | ENVPTR (*env)
#define | ENVONLY env
#define | UNUSED(o) (void)o
#define | CHECK_JNI_EXCEPTION(envptr, clearException)
#define | CALL_CONSTRUCTOR(envptr, classname, classsig, args, ret_obj)
#define | PIN_BYTE_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_BYTE_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_BYTE_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_SHORT_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_SHORT_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_SHORT_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_INT_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_INT_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_INT_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_LONG_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_LONG_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_LONG_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_FLOAT_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_FLOAT_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_FLOAT_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_DOUBLE_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_DOUBLE_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_DOUBLE_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_BOOL_ARRAY(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | PIN_BOOL_ARRAY_CRITICAL(envptr, arrayToPin, outBuf, isCopy, failErrMsg)
#define | UNPIN_BOOL_ARRAY(envptr, pinnedArray, bufToRelease, freeMode)
#define | UNPIN_ARRAY_CRITICAL(envptr, pinnedArray, bufToRelease, freeMode)
#define | PIN_JAVA_STRING(envptr, stringToPin, outString, isCopy, failErrMsg)
#define | UNPIN_JAVA_STRING(envptr, pinnedString, stringToRelease)
#define | H4_JNI_FATAL_ERROR(env, message)
#define | H4_NULL_ARGUMENT_ERROR(env, message)
#define | H4_BAD_ARGUMENT_ERROR(env, message)
#define | H4_OUT_OF_MEMORY_ERROR(env, message)
#define | H4_ASSERTION_ERROR(env, message)
#define | H4_UNIMPLEMENTED(env, message)
#define | H4_LIBRARY_ERROR(env)
#define | H4_RAISE_EXCEPTION(env, message)

## Functions
jboolean | h4JNIFatalError (JNIEnv *, const char *)
jboolean | h4nullArgument (JNIEnv *, const char *)
jboolean | h4badArgument (JNIEnv *, const char *)
jboolean | h4outOfMemory (JNIEnv *, const char *)
jboolean | h4assertion (JNIEnv *env, const char *)
jboolean | h4NotImplemented (JNIEnv *, const char *)
jboolean | h4libraryError (JNIEnv *env)
jboolean | h4raiseException (JNIEnv *, const char *)

## Macro Definition Documentation

## ◆ CALL_CONSTRUCTOR

#define CALL_CONSTRUCTOR | ( |  | envptr,
|  |  | classname,
|  |  | classsig,
|  |  | args,
|  |  | ret_obj )

Value:
do { \
jmethodID constructor; \
jclass cls; \
\
if (NULL == (cls = (*envptr)->FindClass(envptr, (classname)))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, "JNI error: GetObjectClass"); \
} \
if (NULL == (constructor = (*envptr)->GetMethodID(envptr, cls, "<init>", (classsig)))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, "JNI error: GetMethodID failed"); \
} \
if (NULL == (ret_obj = (*envptr)->NewObjectA(envptr, cls, constructor, (args)))) { \
printf("FATAL ERROR: %s: Creation failed\n", classname); \
CHECK_JNI_EXCEPTION(envptr, JNI_FALSE); \
} \
} while (0)

## ◆ CHECK_JNI_EXCEPTION

#define CHECK_JNI_EXCEPTION | ( |  | envptr,
|  |  | clearException )

Value:
do { \
if (JNI_TRUE == (*envptr)->ExceptionCheck(envptr)) { \
if (JNI_TRUE == clearException) \
(*envptr)->ExceptionClear(envptr); \
else \
goto done; \
} \
} while (0)

## ◆ ENVONLY

#define ENVONLY env

## ◆ ENVPTR

#define ENVPTR (*env)

## ◆ H4_ASSERTION_ERROR

#define H4_ASSERTION_ERROR | ( |  | env,
|  |  | message )

Value:
do { \
h4assertion(env, message); \
goto done; \
} while (0)

## ◆ H4_BAD_ARGUMENT_ERROR

#define H4_BAD_ARGUMENT_ERROR | ( |  | env,
|  |  | message )

Value:
do { \
h4badArgument(env, message); \
goto done; \
} while (0)

## ◆ H4_JNI_FATAL_ERROR

#define H4_JNI_FATAL_ERROR | ( |  | env,
|  |  | message )

Value:
do { \
h4JNIFatalError(env, message); \
goto done; \
} while (0)

## ◆ H4_LIBRARY_ERROR

#define H4_LIBRARY_ERROR | ( |  | env | ) |

Value:
do { \
h4libraryError(env); \
goto done; \
} while (0)

## ◆ H4_NULL_ARGUMENT_ERROR

#define H4_NULL_ARGUMENT_ERROR | ( |  | env,
|  |  | message )

Value:
do { \
h4nullArgument(env, message); \
goto done; \
} while (0)

## ◆ H4_OUT_OF_MEMORY_ERROR

#define H4_OUT_OF_MEMORY_ERROR | ( |  | env,
|  |  | message )

Value:
do { \
h4outOfMemory(env, message); \
goto done; \
} while (0)

## ◆ H4_RAISE_EXCEPTION

#define H4_RAISE_EXCEPTION | ( |  | env,
|  |  | message )

Value:
do { \
h4raiseException(env, message); \
goto done; \
} while (0)

## ◆ H4_UNIMPLEMENTED

#define H4_UNIMPLEMENTED | ( |  | env,
|  |  | message )

Value:
do { \
h4NotImplemented(env, message); \
goto done; \
} while (0)

## ◆ PIN_BOOL_ARRAY

#define PIN_BOOL_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetBooleanArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_BOOL_ARRAY_CRITICAL

#define PIN_BOOL_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == \
(outBuf = (jboolean *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_BYTE_ARRAY

#define PIN_BYTE_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetByteArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_BYTE_ARRAY_CRITICAL

#define PIN_BYTE_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (jbyte *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_DOUBLE_ARRAY

#define PIN_DOUBLE_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetDoubleArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_DOUBLE_ARRAY_CRITICAL

#define PIN_DOUBLE_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == \
(outBuf = (jdouble *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_FLOAT_ARRAY

#define PIN_FLOAT_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetFloatArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_FLOAT_ARRAY_CRITICAL

#define PIN_FLOAT_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (jfloat *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_INT_ARRAY

#define PIN_INT_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetIntArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_INT_ARRAY_CRITICAL

#define PIN_INT_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (jint *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_JAVA_STRING

#define PIN_JAVA_STRING | ( |  | envptr,
|  |  | stringToPin,
|  |  | outString,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outString = (*envptr)->GetStringUTFChars(envptr, stringToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_LONG_ARRAY

#define PIN_LONG_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetLongArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_LONG_ARRAY_CRITICAL

#define PIN_LONG_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (jlong *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_SHORT_ARRAY

#define PIN_SHORT_ARRAY | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (*envptr)->GetShortArrayElements(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ PIN_SHORT_ARRAY_CRITICAL

#define PIN_SHORT_ARRAY_CRITICAL | ( |  | envptr,
|  |  | arrayToPin,
|  |  | outBuf,
|  |  | isCopy,
|  |  | failErrMsg )

Value:
do { \
if (NULL == (outBuf = (jshort *)(*envptr)->GetPrimitiveArrayCritical(envptr, arrayToPin, isCopy))) { \
CHECK_JNI_EXCEPTION(envptr, JNI_TRUE); \
H4_JNI_FATAL_ERROR(envptr, failErrMsg); \
} \
} while (0)

## ◆ UNPIN_ARRAY_CRITICAL

#define UNPIN_ARRAY_CRITICAL | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleasePrimitiveArrayCritical(envptr, pinnedArray, bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_BOOL_ARRAY

#define UNPIN_BOOL_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseBooleanArrayElements(envptr, pinnedArray, (jboolean *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_BYTE_ARRAY

#define UNPIN_BYTE_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseByteArrayElements(envptr, pinnedArray, (jbyte *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_DOUBLE_ARRAY

#define UNPIN_DOUBLE_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseDoubleArrayElements(envptr, pinnedArray, (jdouble *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_FLOAT_ARRAY

#define UNPIN_FLOAT_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseFloatArrayElements(envptr, pinnedArray, (jfloat *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_INT_ARRAY

#define UNPIN_INT_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseIntArrayElements(envptr, pinnedArray, (jint *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_JAVA_STRING

#define UNPIN_JAVA_STRING | ( |  | envptr,
|  |  | pinnedString,
|  |  | stringToRelease )

Value:
do { \
(*envptr)->ReleaseStringUTFChars(envptr, pinnedString, stringToRelease); \
} while (0)

## ◆ UNPIN_LONG_ARRAY

#define UNPIN_LONG_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseLongArrayElements(envptr, pinnedArray, (jlong *)bufToRelease, freeMode); \
} while (0)

## ◆ UNPIN_SHORT_ARRAY

#define UNPIN_SHORT_ARRAY | ( |  | envptr,
|  |  | pinnedArray,
|  |  | bufToRelease,
|  |  | freeMode )

Value:
do { \
(*envptr)->ReleaseShortArrayElements(envptr, pinnedArray, (jshort *)bufToRelease, freeMode); \
} while (0)

## ◆ UNUSED

#define UNUSED | ( |  | o | ) | (void)o

## Function Documentation

## ◆ h4assertion()

jboolean h4assertion | ( | JNIEnv * | env,
|  | const char * | )
| extern

## ◆ h4badArgument()

jboolean h4badArgument | ( | JNIEnv * | ,
|  | const char * | )
| extern

## ◆ h4JNIFatalError()

jboolean h4JNIFatalError | ( | JNIEnv * | ,
|  | const char * | )
| extern

## ◆ h4libraryError()

jboolean h4libraryError | ( | JNIEnv * | env | ) |
| extern

## ◆ h4NotImplemented()

jboolean h4NotImplemented | ( | JNIEnv * | ,
|  | const char * | )
| extern

## ◆ h4nullArgument()

jboolean h4nullArgument | ( | JNIEnv * | ,
|  | const char * | )
| extern

## ◆ h4outOfMemory()

jboolean h4outOfMemory | ( | JNIEnv * | ,
|  | const char * | )
| extern

## ◆ h4raiseException()

jboolean h4raiseException | ( | JNIEnv * | ,
|  | const char * | )
| extern