2806 lines
75 KiB
C
Executable file
2806 lines
75 KiB
C
Executable file
/****************************************************************************
|
|
* NCSA HDF *
|
|
* National Comptational Science Alliance *
|
|
* University of Illinois at Urbana-Champaign *
|
|
* 605 E. Springfield, Champaign IL 61820 *
|
|
* *
|
|
* For conditions of distribution and use, see the accompanying *
|
|
* hdf-java/COPYING file. *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
/*
|
|
* This code is the C-interface called by Java programs to access the
|
|
* Property List API Functions of the HDF5 library.
|
|
*
|
|
* Each routine wraps a single HDF entry point, generally with the
|
|
* analogous arguments and return codes.
|
|
*
|
|
* For details of the HDF libraries, see the HDF Documentation at:
|
|
* http://hdf.ncsa.uiuc.edu/HDF5/doc/
|
|
*
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
#include "hdf5.h"
|
|
#include <jni.h>
|
|
#include <stdlib.h>
|
|
|
|
#ifndef FALSE
|
|
#define FALSE 0
|
|
#endif
|
|
|
|
#ifndef TRUE
|
|
#define TRUE (!FALSE)
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
#define ENVPTR (env)
|
|
#define ENVPAR
|
|
#else
|
|
#define ENVPTR (*env)
|
|
#define ENVPAR env,
|
|
#endif
|
|
|
|
extern jboolean h5outOfMemory( JNIEnv *env, char *functName);
|
|
extern jboolean h5JNIFatalError( JNIEnv *env, char *functName);
|
|
extern jboolean h5nullArgument( JNIEnv *env, char *functName);
|
|
extern jboolean h5libraryError( JNIEnv *env );
|
|
extern jboolean h5badArgument( JNIEnv *env, char *functName);
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pcreate
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5__1H5Pcreate
|
|
(JNIEnv *env, jclass clss, jint type)
|
|
{
|
|
hid_t retVal = -1;
|
|
retVal = H5Pcreate((hid_t)type );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pclose
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5__1H5Pclose
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retVal = 0;
|
|
|
|
if (plist > 0)
|
|
retVal = H5Pclose((hid_t)plist );
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_class
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1class
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
hid_t retVal = H5P_NO_CLASS;
|
|
retVal = H5Pget_class((hid_t) plist );
|
|
if (retVal == H5P_NO_CLASS) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pcopy
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5__1H5Pcopy
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
hid_t retVal = -1;
|
|
retVal = H5Pcopy((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_version
|
|
* Signature: (I[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1version
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray version_info)
|
|
{
|
|
herr_t status;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
|
|
if (version_info == NULL) {
|
|
h5nullArgument( env, "H5Pget_version: version_info input array is NULL");
|
|
return -1;
|
|
}
|
|
if (ENVPTR->GetArrayLength(ENVPAR version_info) < 4) {
|
|
h5badArgument( env, "H5Pget_version: version_info input array < 4");
|
|
return -1;
|
|
}
|
|
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR version_info,&isCopy);
|
|
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_version: version_info not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_version((hid_t)plist, (unsigned *)&(theArray[0]),
|
|
(unsigned *)&(theArray[1]), (unsigned *)&(theArray[2]), (unsigned *)&(theArray[3]));
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR version_info,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR version_info,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_userblock
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1userblock
|
|
(JNIEnv *env, jclass clss, jint plist, jlong size)
|
|
{
|
|
long sz;
|
|
herr_t retVal = -1;
|
|
sz = (long)size;
|
|
retVal = H5Pset_userblock((hid_t)plist, (hsize_t)sz );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_userblock
|
|
* Signature: (I[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1userblock
|
|
(JNIEnv *env, jclass clss, jint plist, jlongArray size)
|
|
{
|
|
herr_t status;
|
|
jlong *theArray;
|
|
jboolean isCopy;
|
|
hsize_t s;
|
|
|
|
if (size == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pget_userblock: size is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR size,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_userblock: size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_userblock((hid_t)plist, &s);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = s;
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_sizes
|
|
* Signature: (III)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1sizes
|
|
(JNIEnv *env, jclass clss, jint plist, jint sizeof_addr, jint sizeof_size)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_sizes((hid_t)plist, (size_t)sizeof_addr, (size_t)sizeof_size);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_sizes
|
|
* Signature: (I[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1sizes
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray size)
|
|
{
|
|
herr_t status;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
size_t ss;
|
|
size_t sa;
|
|
|
|
if (size == NULL) {
|
|
h5nullArgument( env, "H5Pget_sizes: size is NULL");
|
|
return -1;
|
|
}
|
|
if (ENVPTR->GetArrayLength(ENVPAR size) < 2) {
|
|
h5badArgument( env, "H5Pget_sizes: size input array < 2 elements");
|
|
return -1;
|
|
}
|
|
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR size,&isCopy);
|
|
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_sizes: size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_sizes((hid_t)plist, &sa, &ss);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR size,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = sa;
|
|
theArray[1] = ss;
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR size,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_sym_k
|
|
* Signature: (III)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1sym_1k
|
|
(JNIEnv *env, jclass clss, jint plist, jint ik, jint lk)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_sym_k((hid_t)plist, (int)ik, (int)lk);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_sym_k
|
|
* Signature: (I[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1sym_1k
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray size)
|
|
{
|
|
herr_t status;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
|
|
if (size == NULL) {
|
|
h5nullArgument( env, "H5Pget_sym_k: size is NULL");
|
|
return -1;
|
|
}
|
|
if (ENVPTR->GetArrayLength(ENVPAR size) < 2) {
|
|
h5badArgument( env, "H5Pget_sym_k: size < 2 elements");
|
|
return -1;
|
|
}
|
|
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR size,&isCopy);
|
|
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_sym_k: size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_sym_k((hid_t)plist, (unsigned *)&(theArray[0]), (unsigned *)&(theArray[1]));
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR size,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR size,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_istore_k
|
|
* Signature: (II)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1istore_1k
|
|
(JNIEnv *env, jclass clss, jint plist, jint ik)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_istore_k((hid_t)plist, (int)ik );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_istore_k
|
|
* Signature: (I[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1istore_1k
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray ik)
|
|
{
|
|
herr_t status;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
|
|
if (ik == NULL) {
|
|
h5nullArgument( env, "H5Pget_store_k: ik is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR ik,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_store_k: size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_istore_k((hid_t)plist, (unsigned *)&(theArray[0]));
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR ik,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR ik,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_layout
|
|
* Signature: (II)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1layout
|
|
(JNIEnv *env, jclass clss, jint plist, jint layout)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_layout((hid_t)plist, (H5D_layout_t)layout );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_layout
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1layout
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
H5D_layout_t retVal = H5D_LAYOUT_ERROR;
|
|
retVal = H5Pget_layout((hid_t)plist);
|
|
if (retVal == H5D_LAYOUT_ERROR) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_chunk
|
|
* Signature: (II[B)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1chunk
|
|
(JNIEnv *env, jclass clss, jint plist, jint ndims, jbyteArray dim)
|
|
{
|
|
herr_t status;
|
|
jbyte *theArray;
|
|
jboolean isCopy;
|
|
hsize_t *da;
|
|
int i;
|
|
hsize_t *lp;
|
|
jlong *jlp;
|
|
int rank;
|
|
|
|
if (dim == NULL) {
|
|
h5nullArgument( env, "H5Pset_chunk: dim array is NULL");
|
|
return -1;
|
|
}
|
|
i = ENVPTR->GetArrayLength(ENVPAR dim);
|
|
rank = i / sizeof(jlong);
|
|
if (rank < ndims) {
|
|
h5badArgument( env, "H5Pset_chunk: dims array < ndims");
|
|
return -1;
|
|
}
|
|
theArray = (jbyte *)ENVPTR->GetByteArrayElements(ENVPAR dim,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pset_chunk: dim array not pinned");
|
|
return -1;
|
|
}
|
|
da = lp = (hsize_t *)malloc(rank * sizeof(hsize_t));
|
|
if (da == NULL) {
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR dim,theArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Pset_chunk: dims not converted to hsize_t");
|
|
return -1;
|
|
}
|
|
jlp = (jlong *)theArray;
|
|
for (i = 0; i < rank; i++) {
|
|
*lp = (hsize_t)*jlp;
|
|
lp++;
|
|
jlp++;
|
|
}
|
|
|
|
status = H5Pset_chunk((hid_t)plist, (int)ndims, da);
|
|
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR dim,theArray,0);
|
|
free(da);
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_chunk
|
|
* Signature: (II[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1chunk
|
|
(JNIEnv *env, jclass clss, jint plist, jint max_ndims, jlongArray dims)
|
|
{
|
|
herr_t status;
|
|
jlong *theArray;
|
|
jboolean isCopy;
|
|
hsize_t *da;
|
|
int i;
|
|
|
|
if (dims == NULL) {
|
|
h5nullArgument( env, "H5Pget_chunk: dims is NULL");
|
|
return -1;
|
|
}
|
|
if (ENVPTR->GetArrayLength(ENVPAR dims) < max_ndims) {
|
|
h5badArgument( env, "H5Pget_chunk: dims array < max_ndims");
|
|
return -1;
|
|
}
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR dims,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_chunk: input dims not pinned");
|
|
return -1;
|
|
}
|
|
da = (hsize_t *)malloc( max_ndims * sizeof(hsize_t));
|
|
if (da == NULL) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR dims, theArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Pget_chunk: dims not converted to hsize_t");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_chunk((hid_t)plist, (int)max_ndims, da);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR dims, theArray,JNI_ABORT);
|
|
free (da);
|
|
h5libraryError(env);
|
|
} else {
|
|
for (i= 0; i < max_ndims; i++) {
|
|
theArray[i] = da[i];
|
|
}
|
|
free (da);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR dims, theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_alignment
|
|
* Signature: (IJJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1alignment
|
|
(JNIEnv *env, jclass clss, jint plist, jlong threshold, jlong alignment)
|
|
{
|
|
long thr;
|
|
long align;
|
|
herr_t retVal = -1;
|
|
thr = (long)threshold;
|
|
align = (long)alignment;
|
|
retVal = H5Pset_alignment((hid_t)plist, (hsize_t)thr, (hsize_t)align);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_alignment
|
|
* Signature: (I[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1alignment
|
|
(JNIEnv *env, jclass clss, jint plist, jlongArray alignment)
|
|
{
|
|
herr_t status;
|
|
jlong *theArray;
|
|
jboolean isCopy;
|
|
hsize_t t;
|
|
hsize_t a;
|
|
|
|
if (alignment == NULL) {
|
|
h5nullArgument( env, "H5Pget_alignment: input alignment is NULL");
|
|
return -1;
|
|
}
|
|
if (ENVPTR->GetArrayLength(ENVPAR alignment) < 2) {
|
|
h5badArgument( env, "H5Pget_alignment: allingment input array < 2");
|
|
return -1;
|
|
}
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR alignment,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_alignment: input array not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_alignment((hid_t)plist, &t, &a);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR alignment, theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = t;
|
|
theArray[1] = a;
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR alignment, theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_external
|
|
* Signature: (ILjava/lang/String;JJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1external
|
|
(JNIEnv *env, jclass clss, jint plist, jstring name, jlong offset, jlong size)
|
|
{
|
|
herr_t status;
|
|
char* file;
|
|
jboolean isCopy;
|
|
long off;
|
|
long sz;
|
|
|
|
off = (long)offset;
|
|
sz = (long)size;
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pset_external: name is NULL");
|
|
return -1;
|
|
}
|
|
file = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (file == NULL) {
|
|
h5JNIFatalError( env, "H5Pset_external: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pset_external((hid_t)plist, file, (off_t)off, (hsize_t)sz);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,file);
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_external_count
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1external_1count
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
int retVal = -1;
|
|
retVal = H5Pget_external_count((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_external
|
|
* Signature: (III[Ljava/lang/String;[J[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1external
|
|
(JNIEnv *env, jclass clss, jint plist, jint idx, jint name_size,
|
|
jobjectArray name, jlongArray size)
|
|
{
|
|
herr_t status;
|
|
jlong *theArray;
|
|
jboolean isCopy;
|
|
char *file;
|
|
jstring str;
|
|
off_t o;
|
|
hsize_t s;
|
|
|
|
if (name_size < 0) {
|
|
h5badArgument( env, "H5Pget_external: name_size < 0");
|
|
return -1;
|
|
}
|
|
else if (name_size == 0) {
|
|
file = NULL;
|
|
}
|
|
else {
|
|
file = (char *)malloc(sizeof(char)*name_size);
|
|
}
|
|
|
|
if (size != NULL) {
|
|
if (ENVPTR->GetArrayLength(ENVPAR size) < 2) {
|
|
free(file);
|
|
h5badArgument( env, "H5Pget_external: size input array < 2");
|
|
return -1;
|
|
}
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR size,&isCopy);
|
|
if (theArray == NULL) {
|
|
free(file);
|
|
h5JNIFatalError( env, "H5Pget_external: size array not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
status = H5Pget_external((hid_t) plist, (int)idx, (size_t)name_size,
|
|
file, (off_t *)&o, (hsize_t *)&s);
|
|
|
|
|
|
if (status < 0) {
|
|
if (size != NULL) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,JNI_ABORT);
|
|
}
|
|
free(file);
|
|
h5libraryError(env);
|
|
return -1;
|
|
}
|
|
|
|
if (size != NULL) {
|
|
theArray[0] = o;
|
|
theArray[1] = s;
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,0);
|
|
}
|
|
|
|
if (file != NULL) {
|
|
/* NewStringUTF may throw OutOfMemoryError */
|
|
str = ENVPTR->NewStringUTF(ENVPAR file);
|
|
if (str == NULL) {
|
|
free(file);
|
|
h5JNIFatalError( env, "H5Pget_external: return array not created");
|
|
return -1;
|
|
}
|
|
/* SetObjectArrayElement may raise exceptions */
|
|
ENVPTR->SetObjectArrayElement(ENVPAR name,0,(jobject)str);
|
|
free(file);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_fill_value
|
|
* Signature: (II[B)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fill_1value
|
|
(JNIEnv *env, jclass clss, jint plist_id, jint type_id, jbyteArray value)
|
|
{
|
|
/*
|
|
unimplemented( env, "H5Pset_fill_value: not implemented yet");
|
|
return -1;
|
|
*/
|
|
jint status;
|
|
jbyte *byteP;
|
|
jboolean isCopy;
|
|
|
|
byteP = ENVPTR->GetByteArrayElements(ENVPAR value,&isCopy);
|
|
status = H5Pset_fill_value((hid_t)plist_id, (hid_t)type_id, byteP);
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR value,byteP,JNI_ABORT);
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_fill_value
|
|
* Signature: (II[B)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1fill_1value
|
|
(JNIEnv *env, jclass clss, jint plist_id, jint type_id, jbyteArray value)
|
|
{
|
|
jint status;
|
|
jbyte *byteP;
|
|
jboolean isCopy;
|
|
|
|
byteP = ENVPTR->GetByteArrayElements(ENVPAR value,&isCopy);
|
|
status = H5Pget_fill_value((hid_t)plist_id, (hid_t)type_id, byteP);
|
|
|
|
if (status < 0)
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR value,byteP,JNI_ABORT);
|
|
else
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR value,byteP,0);
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_filter
|
|
* Signature: (IIII[I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1filter
|
|
(JNIEnv *env, jclass clss, jint plist, jint filter, jint flags,
|
|
jint cd_nelmts, jintArray cd_values)
|
|
{
|
|
herr_t status;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
|
|
if (cd_values == NULL)
|
|
status = H5Pset_filter((hid_t)plist, (H5Z_filter_t)filter,
|
|
(unsigned int)flags, (size_t)cd_nelmts, NULL);
|
|
else
|
|
{
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR cd_values,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError(env, "H5Pset_filter: input array not pinned");
|
|
return -1;
|
|
}
|
|
status = H5Pset_filter((hid_t)plist, (H5Z_filter_t)filter,
|
|
(unsigned int)flags, (size_t)cd_nelmts, (const unsigned int *)theArray);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,theArray,JNI_ABORT);
|
|
}
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_nfilters
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1nfilters
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
int retVal = -1;
|
|
retVal = H5Pget_nfilters((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_filter
|
|
* Signature: (II[I[IILjava/lang/String;)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1filter
|
|
(JNIEnv *env, jclass clss, jint plist, jint filter_number, jintArray flags,
|
|
jintArray cd_nelmts, jintArray cd_values, jint namelen, jobjectArray name)
|
|
{
|
|
herr_t status;
|
|
jint *flagsArray, *cd_nelmtsArray, *cd_valuesArray;
|
|
jboolean isCopy;
|
|
char *filter;
|
|
jstring str;
|
|
|
|
if (namelen <= 0) {
|
|
h5badArgument( env, "H5Pget_filter: namelen <= 0");
|
|
return -1;
|
|
}
|
|
if (flags == NULL) {
|
|
h5badArgument( env, "H5Pget_filter: flags is NULL");
|
|
return -1;
|
|
}
|
|
if (cd_nelmts == NULL) {
|
|
h5badArgument( env, "H5Pget_filter: cd_nelmts is NULL");
|
|
return -1;
|
|
}
|
|
if (cd_values == NULL) {
|
|
h5badArgument( env, "H5Pget_filter: cd_values is NULL");
|
|
return -1;
|
|
}
|
|
filter = (char *)malloc(sizeof(char)*namelen);
|
|
if (filter == NULL) {
|
|
h5outOfMemory( env, "H5Pget_filter: namelent malloc failed");
|
|
return -1;
|
|
}
|
|
flagsArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR flags,&isCopy);
|
|
if (flagsArray == NULL) {
|
|
free(filter);
|
|
h5JNIFatalError(env, "H5Pget_filter: flags array not pinned");
|
|
return -1;
|
|
}
|
|
cd_nelmtsArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR cd_nelmts,&isCopy);
|
|
if (cd_nelmtsArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsArray,JNI_ABORT);
|
|
free(filter);
|
|
h5JNIFatalError(env, "H5Pget_filter: nelmts array not pinned");
|
|
return -1;
|
|
}
|
|
cd_valuesArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR cd_values,&isCopy);
|
|
if (cd_valuesArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_nelmts,cd_nelmtsArray,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsArray,JNI_ABORT);
|
|
free(filter);
|
|
h5JNIFatalError(env, "H5Pget_filter: elmts array not pinned");
|
|
return -1;
|
|
}
|
|
|
|
{
|
|
/* direct cast (size_t *)cd_nelmtsArray fails on 64-bit environment, see bug #1369
|
|
status = H5Pget_filter((hid_t)plist, (int)filter_number, (unsigned int *)flagsArray,
|
|
(size_t *)cd_nelmtsArray, (unsigned int *)cd_valuesArray, (size_t)namelen, filter);
|
|
*/
|
|
int cd_nelmts_temp = *(cd_nelmtsArray);
|
|
size_t cd_nelmts_t = cd_nelmts_temp;
|
|
|
|
status = H5Pget_filter((hid_t)plist, (int)filter_number,
|
|
(unsigned int *)flagsArray, &cd_nelmts_t, (unsigned int *)cd_valuesArray,
|
|
(size_t)namelen, filter);
|
|
*cd_nelmtsArray = cd_nelmts_t;
|
|
}
|
|
|
|
if (status < 0)
|
|
{
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,cd_valuesArray,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_nelmts,cd_nelmtsArray,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsArray,JNI_ABORT);
|
|
free(filter);
|
|
h5libraryError(env);
|
|
return -1;
|
|
}
|
|
else
|
|
{
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,cd_valuesArray,0);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_nelmts,cd_nelmtsArray,0);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsArray,0);
|
|
/* NewStringUTF may throw OutOfMemoryError */
|
|
str = ENVPTR->NewStringUTF(ENVPAR filter);
|
|
if (str == NULL) {
|
|
free(filter);
|
|
h5JNIFatalError(env, "H5Pget_filter: return string not pinned");
|
|
return -1;
|
|
}
|
|
/* SetObjectArrayElement may throw exceptiosn */
|
|
ENVPTR->SetObjectArrayElement(ENVPAR name,0,(jobject)str);
|
|
}
|
|
|
|
free(filter);
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_driver
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1driver
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
hid_t retVal = -1;
|
|
retVal = H5Pget_driver((hid_t) plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
#ifdef removed
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_stdio
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1stdio
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_stdio((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_stdio
|
|
* Signature: (I)B
|
|
*/
|
|
JNIEXPORT jboolean JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1stdio
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retValue;
|
|
retValue = H5Pget_stdio((hid_t)plist);
|
|
|
|
if (retValue >= 0) {
|
|
return JNI_TRUE;
|
|
} else {
|
|
return JNI_FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_sec2
|
|
* Signature: (I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1sec2
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_sec2((hid_t) plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_sec2
|
|
* Signature: (I)B
|
|
*/
|
|
JNIEXPORT jboolean JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1sec2
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retValue;
|
|
|
|
retValue = H5Pget_sec2((hid_t)plist);
|
|
|
|
if (retValue >= 0) {
|
|
return JNI_TRUE;
|
|
} else {
|
|
return JNI_FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_core
|
|
* Signature: (II)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1core
|
|
(JNIEnv *env, jclass clss, jint plist, jint increment)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_core((hid_t)plist, (size_t)increment);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_core
|
|
* Signature: (I[I)B
|
|
*/
|
|
JNIEXPORT jboolean JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1core
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray increment)
|
|
{
|
|
jboolean isCopy;
|
|
herr_t status;
|
|
jint *theArray = NULL;
|
|
|
|
if (increment != NULL) {
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR increment,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError(env, "H5Pget_core: input array not pinned");
|
|
return JNI_FALSE;
|
|
}
|
|
}
|
|
status = H5Pget_core((hid_t)plist, (size_t *)&(theArray[0]));
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR increment,theArray,JNI_ABORT);
|
|
return JNI_FALSE;
|
|
} else {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR increment,theArray,0);
|
|
return JNI_TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_split
|
|
* Signature: (ILjava/lang/String;ILjava/lang/String;I)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1split
|
|
(JNIEnv *env, jclass clss, jint plist, jstring meta_ext, jint meta_plist,
|
|
jstring raw_ext, jint raw_plist)
|
|
{
|
|
herr_t status;
|
|
char *meta, *raw;
|
|
jboolean isCopy;
|
|
|
|
if (meta_ext == NULL) {
|
|
meta = (char *)NULL;
|
|
} else {
|
|
meta = (char *)ENVPTR->GetStringUTFChars(ENVPAR meta_ext,&isCopy);
|
|
if (meta == NULL) {
|
|
h5JNIFatalError(env, "H5Pset_split: meta not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (raw_ext == NULL) {
|
|
raw = (char *)NULL;
|
|
} else {
|
|
raw = (char *)ENVPTR->GetStringUTFChars(ENVPAR raw_ext,&isCopy);
|
|
if (raw == NULL) {
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR meta_ext,meta);
|
|
h5JNIFatalError(env, "H5Pset_split: raw not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
status = H5Pset_split((hid_t)plist, meta, (hid_t)meta_plist, raw, (hid_t)raw_plist);
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR raw_ext,raw);
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR meta_ext,meta);
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_split
|
|
* Signature: (II[Ljava/lang/String;[II[Ljava/lang/String;[I)B
|
|
*/
|
|
JNIEXPORT jboolean JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1split
|
|
(JNIEnv *env, jclass clss, jint plist, jint meta_ext_size, jobjectArray meta_ext,
|
|
jintArray meta_properties, jint raw_ext_size, jobjectArray raw_ext,
|
|
jintArray raw_properties)
|
|
{
|
|
jint status;
|
|
jint *metaArray, *rawArray;
|
|
jboolean isCopy;
|
|
char *meta, *raw;
|
|
jstring meta_str, raw_str;
|
|
|
|
if (meta_ext == NULL) {
|
|
metaArray = NULL;
|
|
} else {
|
|
if (meta_ext_size <=0 ) {
|
|
h5badArgument( env, "H5Pget_split: meta_ext_size <=0");
|
|
return -1;
|
|
}
|
|
meta = (char *)malloc(sizeof(char)*meta_ext_size);
|
|
if (meta == NULL) {
|
|
h5JNIFatalError(env, "H5Pget_split: meta not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
if (raw_ext == NULL ) {
|
|
rawArray = NULL;
|
|
} else {
|
|
if (raw_ext_size <=0 ) {
|
|
h5badArgument( env, "H5Pget_split: raw_ext_size <=0");
|
|
return -1;
|
|
}
|
|
raw = (char *)malloc(sizeof(char)*raw_ext_size);
|
|
if (raw == NULL) {
|
|
free(meta);
|
|
h5JNIFatalError(env, "H5Pget_split: raw not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
metaArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR meta_properties,&isCopy);
|
|
if (metaArray == NULL) {
|
|
free(raw);
|
|
free(meta);
|
|
h5JNIFatalError(env, "H5Pget_split: metaArray not pinned");
|
|
return -1;
|
|
}
|
|
rawArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR raw_properties,&isCopy);
|
|
if (rawArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR meta_properties,metaArray,JNI_ABORT);
|
|
free(raw);
|
|
free(meta);
|
|
h5JNIFatalError(env, "H5Pget_split: rawArray not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_split((hid_t)plist, (size_t)meta_ext_size, meta,
|
|
(hid_t *)metaArray, (size_t)raw_ext_size, raw, (hid_t *)rawArray);
|
|
|
|
if (status < 0)
|
|
{
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR raw_properties,rawArray,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR meta_properties,metaArray,JNI_ABORT);
|
|
free(raw);
|
|
free(meta);
|
|
h5libraryError(env);
|
|
return -1;
|
|
|
|
}
|
|
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR raw_properties,rawArray,0);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR meta_properties,metaArray,0);
|
|
/* NewStringUTF may throw OutOfMemoryError */
|
|
meta_str = ENVPTR->NewStringUTF(ENVPAR meta);
|
|
if (meta_str == NULL) {
|
|
free(raw);
|
|
free(meta);
|
|
h5JNIFatalError(env, "H5Pget_split: return meta_str not pinned");
|
|
return -1;
|
|
}
|
|
|
|
/* SetObjectArrayElement may throw exceptions */
|
|
ENVPTR->SetObjectArrayElement(ENVPAR meta_ext,0,(jobject)meta_str);
|
|
free(meta);
|
|
|
|
/* NewStringUTF may throw OutOfMemoryError */
|
|
raw_str = ENVPTR->NewStringUTF(ENVPAR raw);
|
|
if (meta_str == NULL) {
|
|
free(raw);
|
|
h5JNIFatalError(env, "H5Pget_split: return raw_str not pinned");
|
|
return -1;
|
|
}
|
|
|
|
/* SetObjectArrayElement may throw exceptions */
|
|
ENVPTR->SetObjectArrayElement(ENVPAR raw_ext,0,(jobject)raw_str);
|
|
free(raw);
|
|
|
|
return (jint)status;
|
|
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_cache
|
|
* Signature: (IIID)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1cache
|
|
(JNIEnv *env, jclass clss, jint plist, jint mdc_nelmts, jint rdcc_nelmts,
|
|
jint rdcc_nbytes, jdouble rdcc_w0)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_cache((hid_t)plist, (int)mdc_nelmts, (int)rdcc_nelmts,
|
|
(size_t)rdcc_nbytes, (double) rdcc_w0);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_cache
|
|
* Signature: (I[I[I[D)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1cache
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray mdc_nelmts,
|
|
jintArray rdcc_nelmts, jintArray rdcc_nbytes, jdoubleArray rdcc_w0)
|
|
{
|
|
herr_t status;
|
|
jint mode;
|
|
jdouble *w0Array;
|
|
jint *mdc_nelmtsArray, *rdcc_nelmtsArray, *nbytesArray;
|
|
jboolean isCopy;
|
|
|
|
if (mdc_nelmts == NULL) {
|
|
h5nullArgument( env, "H5Pget_gache: mdc_nelmts is NULL");
|
|
return -1;
|
|
}
|
|
mdc_nelmtsArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR mdc_nelmts,&isCopy);
|
|
if (mdc_nelmtsArray == NULL) {
|
|
h5JNIFatalError(env, "H5Pget_cache: mdc_nelmts array not pinned");
|
|
return -1;
|
|
}
|
|
|
|
if (rdcc_w0 == NULL) {
|
|
w0Array = (jdouble *)NULL;
|
|
} else {
|
|
w0Array = (jdouble *)ENVPTR->GetDoubleArrayElements(ENVPAR rdcc_w0,&isCopy);
|
|
if (w0Array == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR mdc_nelmts,mdc_nelmtsArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Pget_cache: w0_array array not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (rdcc_nelmts == NULL) {
|
|
rdcc_nelmtsArray = (jint *) NULL;
|
|
} else {
|
|
rdcc_nelmtsArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR rdcc_nelmts,&isCopy);
|
|
if (rdcc_nelmtsArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR mdc_nelmts,mdc_nelmtsArray,JNI_ABORT);
|
|
/* exception -- out of memory */
|
|
if (w0Array != NULL) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR rdcc_w0,w0Array,JNI_ABORT);
|
|
}
|
|
h5JNIFatalError(env, "H5Pget_cache: rdcc_nelmts array not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if (rdcc_nbytes == NULL) {
|
|
nbytesArray = (jint *) NULL;
|
|
} else {
|
|
nbytesArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR rdcc_nbytes,&isCopy);
|
|
if (nbytesArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR mdc_nelmts,mdc_nelmtsArray,JNI_ABORT);
|
|
if (w0Array != NULL) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR rdcc_w0,w0Array,JNI_ABORT);
|
|
}
|
|
if (rdcc_nelmtsArray != NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR rdcc_nelmts,rdcc_nelmtsArray,JNI_ABORT);
|
|
}
|
|
h5JNIFatalError(env, "H5Pget_cache: nbytesArray array not pinned");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
status = H5Pget_cache((hid_t)plist, (int *)mdc_nelmtsArray, (size_t *)rdcc_nelmtsArray, (size_t *)nbytesArray,
|
|
(double *)w0Array);
|
|
|
|
if (status < 0) {
|
|
mode = JNI_ABORT;
|
|
} else {
|
|
mode = 0; /* commit and free */
|
|
}
|
|
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR mdc_nelmts,mdc_nelmtsArray,mode);
|
|
|
|
if (rdcc_nelmtsArray != NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR rdcc_nelmts,rdcc_nelmtsArray,mode);
|
|
}
|
|
|
|
if (nbytesArray != NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR rdcc_nbytes,nbytesArray,mode);
|
|
}
|
|
|
|
if (w0Array != NULL) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR rdcc_w0,w0Array,mode);
|
|
}
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
}
|
|
|
|
#ifdef notdef
|
|
|
|
/* DON'T IMPLEMENT THIS!!! */
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_buffer
|
|
* Signature: (II[B[B)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1buffer
|
|
(JNIEnv *env, jclass clss, jint plist, jint size, jbyteArray tconv, jbyteArray bkg)
|
|
{
|
|
jint status;
|
|
jbyte *tconvP, *bkgP;
|
|
jboolean isCopy;
|
|
|
|
if (tconv == NULL)
|
|
tconvP = (jbyte *)NULL;
|
|
else
|
|
tconvP = ENVPTR->GetByteArrayElements(ENVPAR tconv,&isCopy);
|
|
if (bkg == NULL)
|
|
bkgP = (jbyte *)NULL;
|
|
else
|
|
bkgP = ENVPTR->GetByteArrayElements(ENVPAR bkg,&isCopy);
|
|
|
|
status = H5Pset_buffer((hid_t)plist, (size_t)size, tconvP, bkgP);
|
|
|
|
if (tconv != NULL)
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR tconv,tconvP,0);
|
|
if (bkg != NULL)
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR bkg,bkgP,0);
|
|
|
|
return status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_buffer
|
|
* Signature: (I[B[B)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1buffer
|
|
(JNIEnv *env, jclass clss, jint plist, jbyteArray tconv, jbyteArray bkg)
|
|
{
|
|
jint status;
|
|
jbyte *tconvP, *bkgP;
|
|
jboolean isCopy;
|
|
|
|
tconvP = ENVPTR->GetByteArrayElements(ENVPAR tconv,&isCopy);
|
|
bkgP = ENVPTR->GetByteArrayElements(ENVPAR bkg,&isCopy);
|
|
status = H5Pget_buffer((hid_t)plist, tconvP, bkgP);
|
|
|
|
if (status < 0)
|
|
{
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR tconv,tconvP,JNI_ABORT);
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR bkg,bkgP,JNI_ABORT);
|
|
}
|
|
else
|
|
{
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR tconv,tconvP,0);
|
|
ENVPTR->ReleaseByteArrayElements(ENVPAR bkg,bkgP,0);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_preserve
|
|
* Signature: (IB)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1preserve
|
|
(JNIEnv *env, jclass clss, jint plist, jboolean status)
|
|
{
|
|
hbool_t st;
|
|
herr_t retVal = -1;
|
|
|
|
if (status == JNI_TRUE) {
|
|
st = TRUE;
|
|
} else if (status == JNI_FALSE) {
|
|
st = FALSE;
|
|
} else {
|
|
/* exception -- bad argument */
|
|
h5badArgument( env, "H5Pset_preserve: status not TRUE or FALSE");
|
|
return -1;
|
|
}
|
|
retVal = H5Pset_preserve((hid_t)plist, (hbool_t)st);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_preserve
|
|
* Signature: (I)B
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1preserve
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retValue;
|
|
retValue = H5Pget_preserve((hid_t)plist);
|
|
if (retValue < 0) {
|
|
h5libraryError(env);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
return (jint)retValue;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_deflate
|
|
* Signature: (II)B
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1deflate
|
|
(JNIEnv *env, jclass clss, jint plist, jint level)
|
|
{
|
|
herr_t retValue;
|
|
retValue = H5Pset_deflate((hid_t)plist, (int)level);
|
|
if (retValue < 0) {
|
|
h5libraryError(env);
|
|
return JNI_FALSE;
|
|
}
|
|
|
|
return (jint)retValue;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_gc_references
|
|
* Signature: (II)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1gc_1references
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jboolean gc_ref)
|
|
{
|
|
herr_t retVal;
|
|
unsigned gc_ref_val;
|
|
if (gc_ref == JNI_TRUE) {
|
|
gc_ref_val = 1;
|
|
} else {
|
|
gc_ref_val = 0;
|
|
}
|
|
retVal = H5Pset_gc_references((hid_t)fapl_id, gc_ref_val);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
return -1;
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
#ifdef remove
|
|
#ifdef USE_H5_1_2_1
|
|
#define GET_GC H5Pget_gc_reference
|
|
#else
|
|
#define GET_GC H5Pget_gc_references
|
|
#endif
|
|
#endif
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_gc_references
|
|
* Signature: (I[Z)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1gc_1references
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jbooleanArray gc_ref)
|
|
{
|
|
herr_t status;
|
|
jboolean *theArray;
|
|
jboolean isCopy;
|
|
unsigned gc_ref_val = 0;
|
|
|
|
if (gc_ref == NULL) {
|
|
h5nullArgument( env, "H5Pget_gc_references: gc_ref input array is NULL");
|
|
return -1;
|
|
}
|
|
|
|
theArray = (jboolean *)ENVPTR->GetBooleanArrayElements(ENVPAR gc_ref,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_gc_references: gc_ref not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_gc_references((hid_t)fapl_id, (unsigned *)&gc_ref_val);
|
|
#ifdef removed
|
|
status = GET_GC((hid_t)fapl_id, (unsigned *)&gc_ref_val);
|
|
#endif
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseBooleanArrayElements(ENVPAR gc_ref,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
if (gc_ref_val == 1) {
|
|
theArray[0] = JNI_TRUE;
|
|
} else {
|
|
theArray[0] = JNI_FALSE;
|
|
}
|
|
ENVPTR->ReleaseBooleanArrayElements(ENVPAR gc_ref,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_btree_ratios
|
|
* Signature: (IDDD)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1btree_1ratios
|
|
(JNIEnv *env, jclass clss, jint plist_id, jdouble left, jdouble middle, jdouble right)
|
|
{
|
|
herr_t status;
|
|
|
|
status = H5Pset_btree_ratios((hid_t)plist_id, (double)left,(double)middle, (double)right);
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
return -1;
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_btree_ratios
|
|
* Signature: (I[D[D[D)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1btree_1ratios
|
|
(JNIEnv *env, jclass clss, jint plist_id, jdoubleArray left, jdoubleArray middle, jdoubleArray right)
|
|
{
|
|
herr_t status;
|
|
jdouble *leftP, *middleP, *rightP;
|
|
jboolean isCopy;
|
|
|
|
if (left == NULL) {
|
|
h5nullArgument( env, "H5Pget_btree_ratios: left input array is NULL");
|
|
return -1;
|
|
}
|
|
|
|
if (middle == NULL) {
|
|
h5nullArgument( env, "H5Pget_btree_ratios: middle input array is NULL");
|
|
return -1;
|
|
}
|
|
|
|
if (right == NULL) {
|
|
h5nullArgument( env, "H5Pget_btree_ratios: right input array is NULL");
|
|
return -1;
|
|
}
|
|
|
|
leftP = (jdouble *)ENVPTR->GetDoubleArrayElements(ENVPAR left,&isCopy);
|
|
if (leftP == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_btree_ratios: left not pinned");
|
|
return -1;
|
|
}
|
|
|
|
middleP = (jdouble *)ENVPTR->GetDoubleArrayElements(ENVPAR middle,&isCopy);
|
|
if (middleP == NULL) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR left,leftP,JNI_ABORT);
|
|
h5JNIFatalError( env, "H5Pget_btree_ratios: middle not pinned");
|
|
return -1;
|
|
}
|
|
|
|
rightP = (jdouble *)ENVPTR->GetDoubleArrayElements(ENVPAR right,&isCopy);
|
|
if (rightP == NULL) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR left,leftP,JNI_ABORT);
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR middle,middleP,JNI_ABORT);
|
|
h5JNIFatalError( env, "H5Pget_btree_ratios: middle not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_btree_ratios((hid_t)plist_id, (double *)leftP,
|
|
(double *)middleP, (double *)rightP);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR left,leftP,JNI_ABORT);
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR middle,middleP,JNI_ABORT);
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR right,rightP,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR left,leftP,0);
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR middle,middleP,0);
|
|
ENVPTR->ReleaseDoubleArrayElements(ENVPAR right,rightP,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_small_data_block_size
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1small_1data_1block_1size
|
|
(JNIEnv *env, jclass clss, jint plist, jlong size)
|
|
{
|
|
long sz;
|
|
herr_t retVal = -1;
|
|
sz = (long)size;
|
|
retVal = H5Pset_small_data_block_size((hid_t)plist, (hsize_t)sz );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_small_data_block_size
|
|
* Signature: (I[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1small_1data_1block_1size
|
|
(JNIEnv *env, jclass clss, jint plist, jlongArray size)
|
|
{
|
|
herr_t status;
|
|
jlong *theArray;
|
|
jboolean isCopy;
|
|
hsize_t s;
|
|
|
|
if (size == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pget_small_user_block_size: size is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR size,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_userblock: size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_small_data_block_size((hid_t)plist, &s);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = s;
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR size,theArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
|
|
/***************************************************************
|
|
* New APIs for HDF5.1.6 *
|
|
***************************************************************/
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_alloc_time(hid_t plist_id, H5D_alloc_time_t alloc_time )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1alloc_1time
|
|
(JNIEnv *env, jclass clss, jint plist, jint alloc_time)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_alloc_time((hid_t)plist, (H5D_alloc_time_t)alloc_time );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_alloc_time(hid_t plist_id, H5D_alloc_time_t *alloc_time )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1alloc_1time
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray alloc_time)
|
|
{
|
|
herr_t retVal = -1;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
H5D_alloc_time_t time;
|
|
|
|
|
|
if (alloc_time == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pget_alloc_time: alloc_time is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR alloc_time,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_alloc_time: alloc_time not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pget_alloc_time((hid_t)plist, &time );
|
|
|
|
if (retVal < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR alloc_time,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = time;
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR alloc_time,theArray,0);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_fill_time(hid_t plist_id, H5D_fill_time_t fill_time )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fill_1time
|
|
(JNIEnv *env, jclass clss, jint plist, jint fill_time)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_fill_time((hid_t)plist, (H5D_fill_time_t)fill_time );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_fill_time(hid_t plist_id, H5D_fill_time_t *fill_time )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1fill_1time
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray fill_time)
|
|
{
|
|
herr_t retVal = -1;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
H5D_fill_time_t time;
|
|
|
|
|
|
if (fill_time == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pget_fill_time: fill_time is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR fill_time,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_fill_time: fill_time not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pget_fill_time((hid_t)plist, &time );
|
|
|
|
|
|
if (retVal < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR fill_time,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = time;
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR fill_time,theArray,0);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pfill_value_defined(hid_t plist_id, H5D_fill_value_t *status )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pfill_1value_1defined
|
|
(JNIEnv *env, jclass clss, jint plist, jintArray status)
|
|
{
|
|
herr_t retVal = -1;
|
|
jint *theArray;
|
|
jboolean isCopy;
|
|
H5D_fill_value_t value;
|
|
|
|
|
|
if (status == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pfill_value_defined: status is NULL");
|
|
return -1;
|
|
}
|
|
theArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR status,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pfill_value_defined: status not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pfill_value_defined((hid_t)plist, &value );
|
|
|
|
if (retVal < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR status,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = value;
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR status,theArray,0);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_fletcher32(hid_t plist)
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fletcher32
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_fletcher32((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_edc_check(hid_t plist, H5Z_EDC_t check)
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1edc_1check
|
|
(JNIEnv *env, jclass clss, jint plist, jint check)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_edc_check((hid_t)plist, (H5Z_EDC_t)check );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_edc_check(hid_t plist)
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1edc_1check
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
H5Z_EDC_t retVal = (H5Z_EDC_t)-1;
|
|
|
|
retVal = H5Pget_edc_check((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_shuffle(hid_t plist_id)
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1shuffle
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_shuffle((hid_t)plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_szip(hid_t plist, unsigned int options_mask, unsigned int pixels_per_block)
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1szip
|
|
(JNIEnv *env, jclass clss, jint plist, jint options_mask, jint pixels_per_block)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_szip((hid_t)plist, (unsigned int)options_mask, (unsigned int)pixels_per_block);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_hyper_vector_size(hid_t dxpl_id, size_t vector_size )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1hyper_1vector_1size
|
|
(JNIEnv *env, jclass clss, jint plist, jlong vector_size)
|
|
{
|
|
herr_t retVal = -1;
|
|
|
|
retVal = H5Pset_hyper_vector_size((hid_t)plist, (size_t)vector_size);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_hyper_vector_size(hid_t dxpl_id, size_t *vector_size )
|
|
* Signature: (IJ)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1hyper_1vector_1size
|
|
(JNIEnv *env, jclass clss, jint plist, jlongArray vector_size)
|
|
{
|
|
herr_t retVal = -1;
|
|
jlong *theArray;
|
|
size_t size;
|
|
jboolean isCopy;
|
|
|
|
if (vector_size == NULL) {
|
|
/* exception ? */
|
|
h5nullArgument( env, "H5Pget_hyper_vector_size: vector_size is NULL");
|
|
return -1;
|
|
}
|
|
|
|
theArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR vector_size,&isCopy);
|
|
if (theArray == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_hyper_vector_size: vector_size not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pget_hyper_vector_size((hid_t)plist, &size);
|
|
|
|
if (retVal < 0) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR vector_size,theArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
theArray[0] = size;
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR vector_size,theArray,0);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pall_filters_avail(hid_t dcpl_id)
|
|
* Signature: (I)J
|
|
*/
|
|
JNIEXPORT jboolean JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pall_1filters_1avail
|
|
(JNIEnv *env, jclass clss, jint dcpl_id)
|
|
{
|
|
htri_t bval;
|
|
bval = H5Pall_filters_avail((hid_t)dcpl_id);
|
|
if (bval > 0) {
|
|
return JNI_TRUE;
|
|
} else if (bval == 0) {
|
|
return JNI_FALSE;
|
|
} else {
|
|
h5libraryError(env);
|
|
return JNI_FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pmodify_filter(hid_t plist, H5Z_filter_t filter,
|
|
* unsigned int flags, size_t cd_nelmts, const unsigned int cd_values[] )
|
|
* Signature: (III[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pmodify_1filter
|
|
(JNIEnv *env, jclass clss, jint plist, jint filter, jint flags,
|
|
jlong cd_nelmts, jintArray cd_values)
|
|
{
|
|
herr_t status;
|
|
jint *cd_valuesP;
|
|
jboolean isCopy;
|
|
|
|
if (cd_values == NULL) {
|
|
h5nullArgument( env, "H5Pmodify_filter: cd_values is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cd_valuesP = ENVPTR->GetIntArrayElements(ENVPAR cd_values,&isCopy);
|
|
|
|
if (cd_valuesP == NULL) {
|
|
h5JNIFatalError(env, "H5Pmodify_filter: cd_values not pinned");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pmodify_filter((hid_t)plist, (H5Z_filter_t)filter,(const unsigned int)flags,
|
|
(size_t)cd_nelmts, (unsigned int *)cd_valuesP);
|
|
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values, cd_valuesP, 0);
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_filter_by_id( hid_t plist_id, H5Z_filter_t filter,
|
|
* unsigned int *flags, size_t *cd_nelmts, unsigned int cd_values[],
|
|
* size_t namelen, char *name[] )
|
|
* Signature: (III[J)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1filter_1by_1id
|
|
(JNIEnv *env, jclass clss, jint plist, jint filter, jintArray flags,
|
|
jlongArray cd_nelmts, jintArray cd_values, jlong namelen, jobjectArray name)
|
|
{
|
|
herr_t status;
|
|
int i=0;
|
|
jint *cd_valuesP, *flagsP;
|
|
jlong *cd_nelmsP;
|
|
jboolean isCopy;
|
|
size_t *nelmsP;
|
|
int rank;
|
|
long bs;
|
|
char *aName;
|
|
jstring str;
|
|
|
|
bs = (long)namelen;
|
|
if (bs <= 0) {
|
|
h5badArgument( env, "H5Pget_filter_by_id: namelen <= 0");
|
|
return -1;
|
|
}
|
|
|
|
if (flags == NULL) {
|
|
h5nullArgument( env, "H5Pget_filter_by_id: flags is NULL");
|
|
return -1;
|
|
}
|
|
|
|
if (cd_nelmts == NULL) {
|
|
h5nullArgument( env, "H5Pget_filter_by_id: cd_nelms is NULL");
|
|
return -1;
|
|
}
|
|
|
|
if (cd_values == NULL) {
|
|
h5nullArgument( env, "H5Pget_filter_by_id: cd_values is NULL");
|
|
return -1;
|
|
}
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pget_filter_by_id: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
aName = (char*)malloc(sizeof(char)*bs);
|
|
if (aName == NULL) {
|
|
h5outOfMemory( env, "H5Pget_filter_by_id: malloc failed");
|
|
return -1;
|
|
}
|
|
|
|
flagsP = ENVPTR->GetIntArrayElements(ENVPAR flags,&isCopy);
|
|
|
|
if (flagsP == NULL) {
|
|
free(aName);
|
|
h5JNIFatalError(env, "H5Pget_filter_by_id: flags not pinned");
|
|
return -1;
|
|
}
|
|
|
|
cd_nelmsP = ENVPTR->GetLongArrayElements(ENVPAR cd_nelmts,&isCopy);
|
|
|
|
if (cd_nelmsP == NULL) {
|
|
free(aName);
|
|
h5JNIFatalError(env, "H5Pget_filter_by_id: cd_nelms not pinned");
|
|
return -1;
|
|
}
|
|
|
|
nelmsP = (size_t *)malloc( sizeof(size_t));
|
|
|
|
if (nelmsP == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsP,JNI_ABORT);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR cd_nelmts,cd_nelmsP,JNI_ABORT);
|
|
free(aName);
|
|
h5JNIFatalError(env, "H5Pget_filter_by_id: cd_nelmts array not converted to unsigned int.");
|
|
return -1;
|
|
}
|
|
|
|
cd_valuesP = ENVPTR->GetIntArrayElements(ENVPAR cd_values,&isCopy);
|
|
rank = ENVPTR->GetArrayLength(ENVPAR cd_values);
|
|
|
|
if (cd_valuesP == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsP,JNI_ABORT);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR cd_nelmts,cd_nelmsP,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,cd_valuesP,JNI_ABORT);
|
|
free(aName);
|
|
free(nelmsP);
|
|
h5JNIFatalError(env, "H5Pget_filter_by_id: cd_values array not converted to unsigned int.");
|
|
return -1;
|
|
}
|
|
|
|
status = H5Pget_filter_by_id( (hid_t)plist, (H5Z_filter_t)filter,
|
|
(unsigned int *)flagsP, (size_t *)nelmsP, (unsigned int *)cd_valuesP,
|
|
(size_t)namelen, (char *)aName);
|
|
|
|
if (status < 0) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsP,JNI_ABORT);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR cd_nelmts,cd_nelmsP,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,cd_valuesP,JNI_ABORT);
|
|
h5libraryError(env);
|
|
} else {
|
|
|
|
cd_nelmsP[0] = nelmsP[0];
|
|
|
|
str = ENVPTR->NewStringUTF(ENVPAR aName);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR flags,flagsP,0);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR cd_nelmts,cd_nelmsP,0);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR cd_values,cd_valuesP,0);
|
|
}
|
|
|
|
free(aName);
|
|
free(nelmsP);
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset_fclose_degree
|
|
* Signature: (IJI)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fclose_1degree
|
|
(JNIEnv *env, jclass clss, jint plist, jint fc_degree)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_fclose_degree((hid_t) plist, (H5F_close_degree_t) fc_degree);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_fclose_degree
|
|
* Signature: (IJI)I
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1fclose_1degree
|
|
(JNIEnv *env, jclass clss, jint plist)
|
|
{
|
|
H5F_close_degree_t degree;
|
|
herr_t retVal = -1;
|
|
retVal = H5Pget_fclose_degree((hid_t) plist, °ree);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)degree;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* *
|
|
* File access properties *
|
|
* *
|
|
**********************************************************************/
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pset_fapl_family ( hid_t fapl_id, hsize_t memb_size, hid_t memb_fapl_id )
|
|
* Purpose: Sets the file access property list to use the family driver
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fapl_1family
|
|
(JNIEnv *env, jclass clss, jint plist, jlong memb_size, jint memb_plist)
|
|
{
|
|
long ms;
|
|
herr_t retVal = -1;
|
|
ms = (long)memb_size;
|
|
retVal = H5Pset_fapl_family((hid_t)plist, (hsize_t)ms, (hid_t)memb_plist);
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pget_fapl_family ( hid_t fapl_id, hsize_t *memb_size, hid_t *memb_fapl_id )
|
|
* Purpose: Returns file access property list information
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1family
|
|
(JNIEnv *env, jclass clss, jint tid, jlongArray memb_size, jintArray memb_plist)
|
|
{
|
|
herr_t status;
|
|
jlong *sizeArray;
|
|
jint *plistArray;
|
|
jboolean isCopy;
|
|
hsize_t *sa;
|
|
int i;
|
|
int rank;
|
|
|
|
if (memb_size == NULL) {
|
|
h5nullArgument( env, "H5Pget_family: memb_size is NULL");
|
|
return -1;
|
|
}
|
|
if (memb_plist == NULL) {
|
|
h5nullArgument( env, "H5Pget_family: memb_plist is NULL");
|
|
return -1;
|
|
}
|
|
sizeArray = (jlong *)ENVPTR->GetLongArrayElements(ENVPAR memb_size,&isCopy);
|
|
if (sizeArray == NULL) {
|
|
h5JNIFatalError(env, "H5Pget_family: sizeArray not pinned");
|
|
return -1;
|
|
}
|
|
rank = ENVPTR->GetArrayLength(ENVPAR memb_size);
|
|
sa = (hsize_t *)malloc( rank * sizeof(hsize_t));
|
|
if (sa == NULL) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR memb_size,sizeArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Screate-simple: dims not converted to hsize_t");
|
|
return -1;
|
|
}
|
|
plistArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR memb_plist,&isCopy);
|
|
if (plistArray == NULL) {
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR memb_size,sizeArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Pget_family: plistArray not pinned");
|
|
return -1;
|
|
}
|
|
status = H5Pget_fapl_family ((hid_t)tid, sa, (hid_t *)plistArray);
|
|
|
|
if (status < 0)
|
|
{
|
|
free(sa);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR memb_size,sizeArray,JNI_ABORT);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR memb_plist,plistArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
}
|
|
else
|
|
{
|
|
for (i= 0; i < rank; i++) {
|
|
sa[i] = sizeArray[i];
|
|
}
|
|
free(sa);
|
|
ENVPTR->ReleaseLongArrayElements(ENVPAR memb_size,sizeArray,0);
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR memb_plist,plistArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pset_fapl_core( hid_t fapl_id, size_t increment, hbool_t backing_store )
|
|
* Purpose: Modifies the file access property list to use the H5FD_CORE driver
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fapl_1core
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jint increment, jboolean backing_store)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_fapl_core( (hid_t) fapl_id, (size_t) increment, (hbool_t) backing_store );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pget_fapl_core( hid_t fapl_id, size_t *increment, hbool_t *backing_store )
|
|
* Purpose: Queries core file driver properties
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1fapl_1core
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jintArray increment, jbooleanArray backing_store)
|
|
{
|
|
herr_t status;
|
|
jint *incArray;
|
|
jboolean *backArray;
|
|
jboolean isCopy;
|
|
|
|
if (increment == NULL) {
|
|
h5nullArgument( env, "H5Pget_fapl_core: increment is NULL");
|
|
return -1;
|
|
}
|
|
if (backing_store == NULL) {
|
|
h5nullArgument( env, "H5Pget_fapl_core: backing_store is NULL");
|
|
return -1;
|
|
}
|
|
|
|
incArray = (jint *)ENVPTR->GetIntArrayElements(ENVPAR increment,&isCopy);
|
|
if (incArray == NULL) {
|
|
h5JNIFatalError(env, "H5Pget_fapl_core: incArray not pinned");
|
|
return -1;
|
|
}
|
|
|
|
backArray = (jboolean *)ENVPTR->GetBooleanArrayElements(ENVPAR backing_store,&isCopy);
|
|
if (backArray == NULL) {
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR increment,incArray,JNI_ABORT);
|
|
h5JNIFatalError(env, "H5Pget_fapl_core: backArray not pinned");
|
|
return -1;
|
|
}
|
|
status = H5Pget_fapl_core( (hid_t) fapl_id, (size_t *)incArray, (hbool_t *)backArray );
|
|
|
|
if (status < 0)
|
|
{
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR increment,incArray,JNI_ABORT);
|
|
ENVPTR->ReleaseBooleanArrayElements(ENVPAR backing_store,backArray,JNI_ABORT);
|
|
h5libraryError(env);
|
|
}
|
|
else
|
|
{
|
|
ENVPTR->ReleaseIntArrayElements(ENVPAR increment,incArray,0);
|
|
ENVPTR->ReleaseBooleanArrayElements(ENVPAR backing_store,backArray,0);
|
|
}
|
|
|
|
return (jint)status;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pset_family_offset ( hid_t fapl_id, hsize_t offset )
|
|
* Purpose: Sets offset property for low-level access to a file in a family of files
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1family_1offset
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jlong offset)
|
|
{
|
|
herr_t retVal = -1;
|
|
retVal = H5Pset_family_offset ( (hid_t) fapl_id, (hsize_t) offset );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pget_family_offset ( hid_t fapl_id, hsize_t *offset )
|
|
* Purpose: Retrieves a data offset from the file access property list
|
|
*/
|
|
JNIEXPORT jlong JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1family_1offset
|
|
(JNIEnv *env, jclass clss, jint fapl_id)
|
|
{
|
|
hsize_t offset = -1;
|
|
herr_t retVal = -1;
|
|
retVal = H5Pget_family_offset ( (hid_t) fapl_id, &offset );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
return (jlong)offset;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Pset_fapl_log( hid_t fapl_id, const char *logfile, unsigned int flags, size_t buf_size )
|
|
* Purpose: Sets up the use of the logging driver
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset_1fapl_1log
|
|
(JNIEnv *env, jclass clss, jint fapl_id, jstring logfile, jint flags, jint buf_size)
|
|
{
|
|
herr_t retVal = -1;
|
|
char * pLogfile;
|
|
jboolean isCopy;
|
|
|
|
if (logfile == NULL) {
|
|
h5nullArgument( env, "H5Pset_fapl_log: logfile is NULL");
|
|
return -1;
|
|
}
|
|
|
|
pLogfile = (char *)ENVPTR->GetStringUTFChars(ENVPAR logfile,&isCopy);
|
|
|
|
if (pLogfile == NULL) {
|
|
h5JNIFatalError(env, "H5Pset_fapl_log: logfile not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pset_fapl_log( (hid_t) fapl_id, (const char *)pLogfile, (unsigned int) flags, (size_t) buf_size );
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR logfile, pLogfile);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* *
|
|
* New functions release 1.6.3 versus release 1.6.2 *
|
|
* *
|
|
**********************************************************************/
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Signature: herr_t H5Premove_filter (hid_t obj_id, H5Z_filter_t filter)
|
|
* Purpose:
|
|
*/
|
|
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5P1remove_1filter
|
|
(JNIEnv *env, jclass clss, jint obj_id, jint filter)
|
|
{
|
|
herr_t status;
|
|
|
|
status = H5Premove_filter ((hid_t) obj_id, (H5Z_filter_t) filter);
|
|
|
|
if (status < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
/**********************************************************************
|
|
* *
|
|
Modified by Peter Cao on July 26, 2006:
|
|
Some of the Generic Property APIs have callback function
|
|
pointers, which Java does not support. Only the Generic
|
|
Property APIs without function pointers are implemented
|
|
* *
|
|
**********************************************************************/
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pcreate_list
|
|
* Signature: hid_t H5Pcreate_list( hid_t class)
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pcreate_1list
|
|
(JNIEnv *env, jclass clss, jint cls)
|
|
{
|
|
hid_t retVal = -1;
|
|
|
|
retVal = H5Pcopy((hid_t)cls);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pset
|
|
* Signature: herr_t H5Pset( hid_t plid, const char *name, void *value)
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pset
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name, jint val)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
hid_t retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pset: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Pset: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pset((hid_t)plid, cstr, &val);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pexist
|
|
* Signature: htri_t H5Pexist( hid_t id, const char *name )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pexist
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
hid_t retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pexist: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Pexist: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pexist((hid_t)plid, cstr);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_size
|
|
* Signature: int H5Pget_size( hid_t id, const char *name, size_t *size )
|
|
*/
|
|
JNIEXPORT jlong JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1size
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
hid_t retVal = -1;
|
|
size_t size;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pget_size: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Pget_size: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pget_size((hid_t)plid, cstr, &size);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jlong) size;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_nprops
|
|
* Signature: int H5Pget_nprops( hid_t id, size_t *nprops )
|
|
*/
|
|
JNIEXPORT jlong JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1nprops
|
|
(JNIEnv *env, jclass clss, jint plid)
|
|
{
|
|
hid_t retVal = -1;
|
|
size_t nprops;
|
|
|
|
retVal = H5Pget_nprops((hid_t)plid, &nprops);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jlong) nprops;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_class_name
|
|
* Signature: char * H5Pget_class_name( hid_t pcid )
|
|
*/
|
|
JNIEXPORT jstring JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1class_1name
|
|
(JNIEnv *env, jclass clss, jint plid)
|
|
{
|
|
char *c_str;
|
|
jstring j_str;
|
|
|
|
c_str = H5Pget_class_name((hid_t)plid);
|
|
|
|
if (c_str < 0) {
|
|
h5libraryError(env);
|
|
return NULL;
|
|
}
|
|
|
|
j_str = ENVPTR->NewStringUTF(ENVPAR c_str);
|
|
if (j_str == NULL) {
|
|
h5JNIFatalError( env,"H5Pget_class_name: return string failed");
|
|
}
|
|
|
|
return j_str;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget_class_parent
|
|
* Signature: hid_t H5Pget_class_parent( hid_t pcid )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget_1class_1parent
|
|
(JNIEnv *env, jclass clss, jint plid)
|
|
{
|
|
hid_t retVal = -1;
|
|
|
|
retVal = H5Pget_class_parent((hid_t)plid);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint) retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pisa_class
|
|
* Signature: htri_t H5Pisa_class( hid_t plist, hid_t pclass )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pisa_1class
|
|
(JNIEnv *env, jclass clss, jint plid, jint pcls)
|
|
{
|
|
htri_t retVal = -1;
|
|
|
|
retVal = H5Pisa_class((hid_t)plid, (hid_t)pcls);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint) retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pget
|
|
* Signature: herr_t H5Pget( hid_t plid, const char *name, void *value )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pget
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
jint val;
|
|
jint retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pget: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Pget: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pget((hid_t)plid, cstr, &val);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)val;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pequal
|
|
* Signature: htri_t H5Pequal( hid_t id1, hid_t id2 )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pequal
|
|
(JNIEnv *env, jclass clss, jint plid1, jint plid2)
|
|
{
|
|
htri_t retVal = -1;
|
|
|
|
retVal = H5Pequal((hid_t)plid1, (hid_t)plid2);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint) retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pcopy_prop
|
|
* Signature: herr_t H5Pcopy_prop( hid_t dst_id, hid_t src_id, const char *name )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pcopy_1prop
|
|
(JNIEnv *env, jclass clss, jint dst_plid, jint src_plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
jint retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Pcopy_prop: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Pcopy_prop: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Pcopy_prop((hid_t)dst_plid, (hid_t)src_plid, cstr);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Premove
|
|
* Signature: herr_t H5Premove( hid_t plid; const char *name )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Premove
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
jint retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Premove: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Premove: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Premove((hid_t)plid, cstr);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Punregister
|
|
* Signature: herr_t H5Punregister( H5P_class_t class, const char *name )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Punregister
|
|
(JNIEnv *env, jclass clss, jint plid, jstring name)
|
|
{
|
|
char* cstr;
|
|
jboolean isCopy;
|
|
jint retVal = -1;
|
|
|
|
if (name == NULL) {
|
|
h5nullArgument( env, "H5Punregister: name is NULL");
|
|
return -1;
|
|
}
|
|
|
|
cstr = (char *)ENVPTR->GetStringUTFChars(ENVPAR name,&isCopy);
|
|
if (cstr == NULL) {
|
|
h5JNIFatalError( env, "H5Punregister: name not pinned");
|
|
return -1;
|
|
}
|
|
|
|
retVal = H5Punregister((hid_t)plid, cstr);
|
|
|
|
ENVPTR->ReleaseStringUTFChars(ENVPAR name,cstr);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint)retVal;
|
|
}
|
|
|
|
/*
|
|
* Class: ncsa_hdf_hdf5lib_H5
|
|
* Method: H5Pclose_list
|
|
* Signature: herr_t H5Pclose_class( hid_t plist )
|
|
*/
|
|
JNIEXPORT jint JNICALL Java_ncsa_hdf_hdf5lib_H5_H5Pclose_1class
|
|
(JNIEnv *env, jclass clss, jint plid)
|
|
{
|
|
hid_t retVal = -1;
|
|
|
|
retVal = H5Pclose_class((hid_t)plid);
|
|
|
|
if (retVal < 0) {
|
|
h5libraryError(env);
|
|
}
|
|
|
|
return (jint) retVal;
|
|
}
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|