mirror of
https://github.com/HDFGroup/hdf5.git
synced 2026-09-25 04:09:44 +03:00
Allen Byrne
b754dcb8f2
FFM build requires Java 25, Jextract 25. Generates FFM bindings during configure. JNI is default when the requirements are not met or can be forced. Presets added for maven and FFM - JNI is default selection. Enhanced Maven options will work with either JNI or FFM New Workflows for testing and maven uploads. Extensive documentation changes for java.
946 lines
38 KiB
Java
946 lines
38 KiB
Java
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
|
* Copyright by The HDF Group. *
|
|
* All rights reserved. *
|
|
* *
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
* terms governing use, modification, and redistribution, is contained in *
|
|
* the LICENSE file, which can be found at the root of the source code *
|
|
* distribution tree, or in https://www.hdfgroup.org/licenses. *
|
|
* If you do not have access to either file, you may request a copy from *
|
|
* help@hdfgroup.org. *
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
|
|
|
package hdf.hdf5lib;
|
|
|
|
import java.util.Arrays;
|
|
|
|
import hdf.hdf5lib.exceptions.HDF5Exception;
|
|
import hdf.hdf5lib.exceptions.HDF5JavaException;
|
|
|
|
/**
|
|
* \page HDFARRAY Java Array Conversion
|
|
* This is a class for handling multidimensional arrays for HDF.
|
|
* <p>
|
|
* The purpose is to allow the storage and retrieval of arbitrary array types containing scientific data.
|
|
* <p>
|
|
* The methods support the conversion of an array to and from Java to a one-dimensional array of bytes
|
|
* suitable for I/O by the C library. <p> This class heavily uses the
|
|
* @ref HDFNATIVE
|
|
* class to convert between Java and C representations.
|
|
*/
|
|
|
|
public class HDFArray {
|
|
private Object _theArray = null;
|
|
private ArrayDescriptor _desc = null;
|
|
private byte[] _barray = null;
|
|
|
|
// public HDFArray() {}
|
|
|
|
/**
|
|
* The input must be a Java Array (possibly multidimensional) of primitive numbers or sub-classes of
|
|
* Number. <p> The input is analysed to determine the number of dimensions and size of each dimension, as
|
|
* well as the type of the elements. <p> The description is saved in private variables, and used to
|
|
* convert data.
|
|
*
|
|
* @param anArray
|
|
* The array object.
|
|
* @exception hdf.hdf5lib.exceptions.HDF5JavaException
|
|
* object is not an array.
|
|
*/
|
|
public HDFArray(Object anArray) throws HDF5JavaException
|
|
{
|
|
if (anArray == null) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: array is null?: ");
|
|
}
|
|
Class tc = anArray.getClass();
|
|
if (tc.isArray() == false) {
|
|
/* exception: not an array */
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: not an array?: ");
|
|
throw(ex);
|
|
}
|
|
_theArray = anArray;
|
|
_desc = new ArrayDescriptor(_theArray);
|
|
|
|
/* extra error checking -- probably not needed */
|
|
if (_desc == null) {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: internal error: array description failed?: ");
|
|
throw(ex);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allocate a one-dimensional array of bytes sufficient to store the array.
|
|
*
|
|
* @return A one-D array of bytes, filled with zeroes. The bytes are sufficient to hold the data of the
|
|
* Array passed to the constructor.
|
|
* @exception hdf.hdf5lib.exceptions.HDF5JavaException
|
|
* Allocation failed.
|
|
*/
|
|
|
|
public byte[] emptyBytes() throws HDF5JavaException
|
|
{
|
|
byte[] b = null;
|
|
|
|
if ((ArrayDescriptor.dims == 1) && (ArrayDescriptor.NT == 'B')) {
|
|
b = (byte[])_theArray;
|
|
}
|
|
else {
|
|
b = new byte[ArrayDescriptor.totalSize];
|
|
}
|
|
if (b == null) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: emptyBytes: allocation failed");
|
|
throw(ex);
|
|
}
|
|
return (b);
|
|
}
|
|
|
|
/**
|
|
* Given a Java array of numbers, convert it to a one-dimensional array of bytes in correct native order.
|
|
*
|
|
* @return A one-D array of bytes, constructed from the Array passed to the constructor.
|
|
* @exception hdf.hdf5lib.exceptions.HDF5JavaException
|
|
* the object not an array or other internal error.
|
|
*/
|
|
public byte[] byteify() throws HDF5JavaException
|
|
{
|
|
if (_barray != null) {
|
|
return _barray;
|
|
}
|
|
|
|
if (_theArray == null) {
|
|
/* exception: not an array */
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify not an array?: ");
|
|
throw(ex);
|
|
}
|
|
|
|
if (ArrayDescriptor.dims == 1) {
|
|
/* special case */
|
|
if (ArrayDescriptor.NT == 'B') {
|
|
/* really special case! */
|
|
_barray = (byte[])_theArray;
|
|
return _barray;
|
|
}
|
|
else {
|
|
try {
|
|
_barray = new byte[ArrayDescriptor.totalSize];
|
|
|
|
byte[] therow;
|
|
if (ArrayDescriptor.NT == 'I') {
|
|
therow = HDFNativeData.intToByte(0, ArrayDescriptor.dimlen[1], (int[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'S') {
|
|
therow = HDFNativeData.shortToByte(0, ArrayDescriptor.dimlen[1], (short[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'F') {
|
|
therow = HDFNativeData.floatToByte(0, ArrayDescriptor.dimlen[1], (float[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'J') {
|
|
therow = HDFNativeData.longToByte(0, ArrayDescriptor.dimlen[1], (long[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'D') {
|
|
therow =
|
|
HDFNativeData.doubleToByte(0, ArrayDescriptor.dimlen[1], (double[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'L') {
|
|
if (ArrayDescriptor.className.equals("java.lang.Byte")) {
|
|
therow = ByteObjToByte((Byte[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
|
|
therow = IntegerToByte((Integer[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Short")) {
|
|
therow = ShortToByte((Short[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Float")) {
|
|
therow = FloatObjToByte((Float[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Double")) {
|
|
therow = DoubleObjToByte((Double[])_theArray);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Long")) {
|
|
therow = LongObjToByte((Long[])_theArray);
|
|
}
|
|
else {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: unknown type of Object?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
else {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: unknown type of data?");
|
|
throw(ex);
|
|
}
|
|
System.arraycopy(therow, 0, _barray, 0,
|
|
(ArrayDescriptor.dimlen[1] * ArrayDescriptor.NTsize));
|
|
return _barray;
|
|
}
|
|
catch (OutOfMemoryError err) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify array too big?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
_barray = new byte[ArrayDescriptor.totalSize];
|
|
}
|
|
catch (OutOfMemoryError err) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify array too big?");
|
|
throw(ex);
|
|
}
|
|
|
|
Object oo = _theArray;
|
|
int n = 0; /* the current byte */
|
|
int index = 0;
|
|
int i;
|
|
while (n < ArrayDescriptor.totalSize) {
|
|
oo = ArrayDescriptor.objs[0];
|
|
index = n / ArrayDescriptor.bytetoindex[0];
|
|
index %= ArrayDescriptor.dimlen[0];
|
|
for (i = 0; i < (ArrayDescriptor.dims); i++) {
|
|
index = n / ArrayDescriptor.bytetoindex[i];
|
|
index %= ArrayDescriptor.dimlen[i];
|
|
|
|
if (index == ArrayDescriptor.currentindex[i]) {
|
|
/* then use cached copy */
|
|
oo = ArrayDescriptor.objs[i];
|
|
}
|
|
else {
|
|
/* check range of index */
|
|
if (index > (ArrayDescriptor.dimlen[i] - 1)) {
|
|
throw new java.lang.IndexOutOfBoundsException("HDFArray: byteify index OOB?");
|
|
}
|
|
oo = java.lang.reflect.Array.get(oo, index);
|
|
ArrayDescriptor.currentindex[i] = index;
|
|
ArrayDescriptor.objs[i] = oo;
|
|
}
|
|
}
|
|
|
|
/* byte-ify */
|
|
byte arow[];
|
|
try {
|
|
if (ArrayDescriptor.NT == 'J') {
|
|
arow = HDFNativeData.longToByte(0, ArrayDescriptor.dimlen[ArrayDescriptor.dims],
|
|
(long[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'I') {
|
|
arow = HDFNativeData.intToByte(0, ArrayDescriptor.dimlen[ArrayDescriptor.dims],
|
|
(int[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'S') {
|
|
arow = HDFNativeData.shortToByte(0, ArrayDescriptor.dimlen[ArrayDescriptor.dims],
|
|
(short[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'B') {
|
|
arow = (byte[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1];
|
|
}
|
|
else if (ArrayDescriptor.NT == 'F') {
|
|
/* 32 bit float */
|
|
arow = HDFNativeData.floatToByte(0, ArrayDescriptor.dimlen[ArrayDescriptor.dims],
|
|
(float[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'D') {
|
|
/* 64 bit float */
|
|
arow =
|
|
HDFNativeData.doubleToByte(0, ArrayDescriptor.dimlen[ArrayDescriptor.dims],
|
|
(double[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.NT == 'L') {
|
|
if (ArrayDescriptor.className.equals("java.lang.Byte")) {
|
|
arow = ByteObjToByte((Byte[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
|
|
arow = IntegerToByte((Integer[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Short")) {
|
|
arow = ShortToByte((Short[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Float")) {
|
|
arow = FloatObjToByte((Float[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Double")) {
|
|
arow = DoubleObjToByte((Double[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Long")) {
|
|
arow = LongObjToByte((Long[])ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
|
|
}
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: byteify Object type not implemented?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: byteify unknown type not implemented?");
|
|
throw(ex);
|
|
}
|
|
System.arraycopy(arow, 0, _barray, n,
|
|
(ArrayDescriptor.dimlen[ArrayDescriptor.dims] * ArrayDescriptor.NTsize));
|
|
n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1];
|
|
}
|
|
catch (OutOfMemoryError err) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify array too big?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
/* assert: the whole array is completed--currentindex should == len - 1 */
|
|
/* error checks */
|
|
if (n < ArrayDescriptor.totalSize) {
|
|
throw new java.lang.InternalError(
|
|
new String("HDFArray::byteify: Panic didn't complete all input data: n= " + n +
|
|
" size = " + ArrayDescriptor.totalSize));
|
|
}
|
|
for (i = 0; i < ArrayDescriptor.dims; i++) {
|
|
if (ArrayDescriptor.currentindex[i] != ArrayDescriptor.dimlen[i] - 1) {
|
|
throw new java.lang.InternalError(new String("Panic didn't complete all data: currentindex[" +
|
|
i + "] = " + ArrayDescriptor.currentindex[i] +
|
|
" (should be " +
|
|
(ArrayDescriptor.dimlen[i] - 1) + " ?)"));
|
|
}
|
|
}
|
|
return _barray;
|
|
}
|
|
|
|
/**
|
|
* Given a one-dimensional array of bytes representing numbers, convert it to a java array of the shape
|
|
* and size passed to the constructor.
|
|
*
|
|
* @param bytes
|
|
* The bytes to construct the Array.
|
|
* @return
|
|
* An Array (possibly multidimensional) of primitive or number objects.
|
|
* @exception
|
|
* hdf.hdf5lib.exceptions.HDF5JavaException the object not an array or other internal error.
|
|
*/
|
|
public Object arrayify(byte[] bytes) throws HDF5JavaException
|
|
{
|
|
if (_theArray == null) {
|
|
/* exception: not an array */
|
|
HDF5JavaException ex = new HDF5JavaException("arrayify: not an array?: ");
|
|
throw(ex);
|
|
}
|
|
|
|
if (java.lang.reflect.Array.getLength(bytes) != ArrayDescriptor.totalSize) {
|
|
/* exception: array not right size */
|
|
HDF5JavaException ex = new HDF5JavaException("arrayify: array is wrong size?: ");
|
|
throw(ex);
|
|
}
|
|
_barray = bytes; /* hope that the bytes are correct.... */
|
|
|
|
if (ArrayDescriptor.dims == 1) {
|
|
/* special case */
|
|
/* 2 data copies here! */
|
|
try {
|
|
if (ArrayDescriptor.NT == 'I') {
|
|
int[] x = HDFNativeData.byteToInt(_barray);
|
|
System.arraycopy(x, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'S') {
|
|
short[] x = HDFNativeData.byteToShort(_barray);
|
|
System.arraycopy(x, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'F') {
|
|
float x[] = HDFNativeData.byteToFloat(_barray);
|
|
System.arraycopy(x, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'J') {
|
|
long x[] = HDFNativeData.byteToLong(_barray);
|
|
System.arraycopy(x, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'D') {
|
|
double x[] = HDFNativeData.byteToDouble(_barray);
|
|
System.arraycopy(x, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'B') {
|
|
System.arraycopy(_barray, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.NT == 'L') {
|
|
if (ArrayDescriptor.className.equals("java.lang.Byte")) {
|
|
Byte I[] = ByteToByteObj(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
|
|
Integer I[] = ByteToInteger(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Short")) {
|
|
Short I[] = ByteToShort(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Float")) {
|
|
Float I[] = ByteToFloatObj(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Double")) {
|
|
Double I[] = ByteToDoubleObj(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else if (ArrayDescriptor.className.equals("java.lang.Long")) {
|
|
Long I[] = ByteToLongObj(_barray);
|
|
System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
|
|
return _theArray;
|
|
}
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("arrayify: Object type not implemented yet...");
|
|
throw(ex);
|
|
}
|
|
}
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("arrayify: unknown type not implemented yet...");
|
|
throw(ex);
|
|
}
|
|
}
|
|
catch (OutOfMemoryError err) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: arrayify array too big?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
/* Assert dims >= 2 */
|
|
|
|
Object oo = _theArray;
|
|
int n = 0; /* the current byte */
|
|
int m = 0; /* the current array index */
|
|
int index = 0;
|
|
int i;
|
|
Object flattenedArray = null;
|
|
|
|
switch (ArrayDescriptor.NT) {
|
|
case 'J':
|
|
flattenedArray = (Object)HDFNativeData.byteToLong(_barray);
|
|
break;
|
|
case 'S':
|
|
flattenedArray = (Object)HDFNativeData.byteToShort(_barray);
|
|
break;
|
|
case 'I':
|
|
flattenedArray = (Object)HDFNativeData.byteToInt(_barray);
|
|
break;
|
|
case 'F':
|
|
flattenedArray = (Object)HDFNativeData.byteToFloat(_barray);
|
|
break;
|
|
case 'D':
|
|
flattenedArray = (Object)HDFNativeData.byteToDouble(_barray);
|
|
break;
|
|
case 'B':
|
|
flattenedArray = (Object)_barray;
|
|
break;
|
|
case 'L': {
|
|
if (ArrayDescriptor.className.equals("java.lang.Byte"))
|
|
flattenedArray = (Object)ByteToByteObj(_barray);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Short"))
|
|
flattenedArray = (Object)ByteToShort(_barray);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Integer"))
|
|
flattenedArray = (Object)ByteToInteger(_barray);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Long"))
|
|
flattenedArray = (Object)ByteToLongObj(_barray);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Float"))
|
|
flattenedArray = (Object)ByteToFloatObj(_barray);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Double"))
|
|
flattenedArray = (Object)ByteToDoubleObj(_barray);
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: unsupported Object type: " + ArrayDescriptor.NT);
|
|
throw(ex);
|
|
}
|
|
break;
|
|
} // end of statement for arrays of boxed objects
|
|
default:
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: unknown or unsupported type: " + ArrayDescriptor.NT);
|
|
throw(ex);
|
|
} // end of switch statement for arrays of primitives
|
|
|
|
while (n < ArrayDescriptor.totalSize) {
|
|
oo = ArrayDescriptor.objs[0];
|
|
index = n / ArrayDescriptor.bytetoindex[0];
|
|
index %= ArrayDescriptor.dimlen[0];
|
|
for (i = 0; i < (ArrayDescriptor.dims); i++) {
|
|
index = n / ArrayDescriptor.bytetoindex[i];
|
|
index %= ArrayDescriptor.dimlen[i];
|
|
|
|
if (index == ArrayDescriptor.currentindex[i]) {
|
|
/* then use cached copy */
|
|
oo = ArrayDescriptor.objs[i];
|
|
}
|
|
else {
|
|
/* check range of index */
|
|
if (index > (ArrayDescriptor.dimlen[i] - 1)) {
|
|
System.out.println("out of bounds?");
|
|
return null;
|
|
}
|
|
oo = java.lang.reflect.Array.get(oo, index);
|
|
ArrayDescriptor.currentindex[i] = index;
|
|
ArrayDescriptor.objs[i] = oo;
|
|
}
|
|
}
|
|
|
|
/* array-ify */
|
|
try {
|
|
Object arow = null;
|
|
int mm = m + ArrayDescriptor.dimlen[ArrayDescriptor.dims];
|
|
switch (ArrayDescriptor.NT) {
|
|
case 'B':
|
|
arow = (Object)Arrays.copyOfRange((byte[])flattenedArray, m, mm);
|
|
break;
|
|
case 'S':
|
|
arow = (Object)Arrays.copyOfRange((short[])flattenedArray, m, mm);
|
|
break;
|
|
case 'I':
|
|
arow = (Object)Arrays.copyOfRange((int[])flattenedArray, m, mm);
|
|
break;
|
|
case 'J':
|
|
arow = (Object)Arrays.copyOfRange((long[])flattenedArray, m, mm);
|
|
break;
|
|
case 'F':
|
|
arow = (Object)Arrays.copyOfRange((float[])flattenedArray, m, mm);
|
|
break;
|
|
case 'D':
|
|
arow = (Object)Arrays.copyOfRange((double[])flattenedArray, m, mm);
|
|
break;
|
|
case 'L': {
|
|
if (ArrayDescriptor.className.equals("java.lang.Byte"))
|
|
arow = (Object)Arrays.copyOfRange((Byte[])flattenedArray, m, mm);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Short"))
|
|
arow = (Object)Arrays.copyOfRange((Short[])flattenedArray, m, mm);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Integer"))
|
|
arow = (Object)Arrays.copyOfRange((Integer[])flattenedArray, m, mm);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Long"))
|
|
arow = (Object)Arrays.copyOfRange((Long[])flattenedArray, m, mm);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Float"))
|
|
arow = (Object)Arrays.copyOfRange((Float[])flattenedArray, m, mm);
|
|
else if (ArrayDescriptor.className.equals("java.lang.Double"))
|
|
arow = (Object)Arrays.copyOfRange((Double[])flattenedArray, m, mm);
|
|
else {
|
|
HDF5JavaException ex =
|
|
new HDF5JavaException("HDFArray: unsupported Object type: " + ArrayDescriptor.NT);
|
|
throw(ex);
|
|
}
|
|
break;
|
|
} // end of statement for arrays of boxed numerics
|
|
} // end of switch statement for arrays of primitives
|
|
|
|
java.lang.reflect.Array.set(ArrayDescriptor.objs[ArrayDescriptor.dims - 2],
|
|
(ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), arow);
|
|
n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1];
|
|
ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++;
|
|
m = mm;
|
|
}
|
|
catch (OutOfMemoryError err) {
|
|
HDF5JavaException ex = new HDF5JavaException("HDFArray: arrayify array too big?");
|
|
throw(ex);
|
|
}
|
|
}
|
|
|
|
/* assert: the whole array is completed--currentindex should == len - 1 */
|
|
/* error checks */
|
|
if (n < ArrayDescriptor.totalSize) {
|
|
throw new java.lang.InternalError(
|
|
new String("HDFArray::arrayify Panic didn't complete all input data: n= " + n +
|
|
" size = " + ArrayDescriptor.totalSize));
|
|
}
|
|
for (i = 0; i <= ArrayDescriptor.dims - 2; i++) {
|
|
if (ArrayDescriptor.currentindex[i] != ArrayDescriptor.dimlen[i] - 1) {
|
|
throw new java.lang.InternalError(
|
|
new String("HDFArray::arrayify Panic didn't complete all data: currentindex[" + i +
|
|
"] = " + ArrayDescriptor.currentindex[i] + " (should be " +
|
|
(ArrayDescriptor.dimlen[i] - 1) + "?"));
|
|
}
|
|
}
|
|
if (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1] !=
|
|
ArrayDescriptor.dimlen[ArrayDescriptor.dims - 1]) {
|
|
throw new java.lang.InternalError(new String(
|
|
"HDFArray::arrayify Panic didn't complete all data: currentindex[" + i + "] = " +
|
|
ArrayDescriptor.currentindex[i] + " (should be " + (ArrayDescriptor.dimlen[i]) + "?"));
|
|
}
|
|
|
|
return _theArray;
|
|
}
|
|
|
|
private byte[] IntegerToByte(Integer in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength(in);
|
|
int[] out = new int[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].intValue();
|
|
}
|
|
return HDFNativeData.intToByte(0, nelems, out);
|
|
}
|
|
|
|
private Integer[] ByteToInteger(byte[] bin)
|
|
{
|
|
int in[] = HDFNativeData.byteToInt(bin);
|
|
int nelems = java.lang.reflect.Array.getLength(in);
|
|
Integer[] out = new Integer[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Integer.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Integer[] ByteToInteger(int start, int len, byte[] bin)
|
|
{
|
|
int in[] = HDFNativeData.byteToInt(start, len, bin);
|
|
int nelems = java.lang.reflect.Array.getLength(in);
|
|
Integer[] out = new Integer[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Integer.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private byte[] ShortToByte(Short in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength(in);
|
|
short[] out = new short[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].shortValue();
|
|
}
|
|
return HDFNativeData.shortToByte(0, nelems, out);
|
|
}
|
|
|
|
private Short[] ByteToShort(byte[] bin)
|
|
{
|
|
short in[] = HDFNativeData.byteToShort(bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Short[] out = new Short[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Short.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Short[] ByteToShort(int start, int len, byte[] bin)
|
|
{
|
|
short in[] = (short[])HDFNativeData.byteToShort(start, len, bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Short[] out = new Short[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Short.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private byte[] ByteObjToByte(Byte in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
byte[] out = new byte[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].byteValue();
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Byte[] ByteToByteObj(byte[] bin)
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength((Object)bin);
|
|
Byte[] out = new Byte[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Byte.valueOf(bin[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Byte[] ByteToByteObj(int start, int len, byte[] bin)
|
|
{
|
|
Byte[] out = new Byte[len];
|
|
|
|
for (int i = 0; i < len; i++) {
|
|
out[i] = Byte.valueOf(bin[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private byte[] FloatObjToByte(Float in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
float[] out = new float[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].floatValue();
|
|
}
|
|
return HDFNativeData.floatToByte(0, nelems, out);
|
|
}
|
|
|
|
private Float[] ByteToFloatObj(byte[] bin)
|
|
{
|
|
float in[] = (float[])HDFNativeData.byteToFloat(bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Float[] out = new Float[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Float.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Float[] ByteToFloatObj(int start, int len, byte[] bin)
|
|
{
|
|
float in[] = (float[])HDFNativeData.byteToFloat(start, len, bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Float[] out = new Float[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Float.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private byte[] DoubleObjToByte(Double in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
double[] out = new double[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].doubleValue();
|
|
}
|
|
return HDFNativeData.doubleToByte(0, nelems, out);
|
|
}
|
|
|
|
private Double[] ByteToDoubleObj(byte[] bin)
|
|
{
|
|
double in[] = (double[])HDFNativeData.byteToDouble(bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Double[] out = new Double[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Double.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Double[] ByteToDoubleObj(int start, int len, byte[] bin)
|
|
{
|
|
double in[] = (double[])HDFNativeData.byteToDouble(start, len, bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Double[] out = new Double[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Double.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private byte[] LongObjToByte(Long in[])
|
|
{
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
long[] out = new long[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = in[i].longValue();
|
|
}
|
|
return HDFNativeData.longToByte(0, nelems, out);
|
|
}
|
|
|
|
private Long[] ByteToLongObj(byte[] bin)
|
|
{
|
|
long in[] = (long[])HDFNativeData.byteToLong(bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Long[] out = new Long[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Long.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
private Long[] ByteToLongObj(int start, int len, byte[] bin)
|
|
{
|
|
long in[] = (long[])HDFNativeData.byteToLong(start, len, bin);
|
|
int nelems = java.lang.reflect.Array.getLength((Object)in);
|
|
Long[] out = new Long[nelems];
|
|
|
|
for (int i = 0; i < nelems; i++) {
|
|
out[i] = Long.valueOf(in[i]);
|
|
}
|
|
return out;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This private class is used by HDFArray to discover the shape and type of an arbitrary array.
|
|
* <p>
|
|
* We use java.lang.reflection here.
|
|
*/
|
|
class ArrayDescriptor {
|
|
static String theType = "";
|
|
static Class theClass = null;
|
|
static int[] dimlen = null;
|
|
static int[] dimstart = null;
|
|
static int[] currentindex = null;
|
|
static int[] bytetoindex = null;
|
|
static int totalSize = 0;
|
|
static int totalElements = 0;
|
|
static Object[] objs = null;
|
|
static char NT = ' '; /* must be B,S,I,L,F,D, else error */
|
|
static int NTsize = 0;
|
|
static int dims = 0;
|
|
static String className;
|
|
|
|
public ArrayDescriptor(Object anArray) throws HDF5JavaException
|
|
{
|
|
Class tc = anArray.getClass();
|
|
if (tc.isArray() == false) {
|
|
/* exception: not an array */
|
|
HDF5JavaException ex = new HDF5JavaException("ArrayDescriptor: not an array?: ");
|
|
throw(ex);
|
|
}
|
|
|
|
theClass = tc;
|
|
|
|
/*
|
|
* parse the type descriptor to discover the shape of the array
|
|
*/
|
|
String ss = tc.toString();
|
|
theType = ss;
|
|
int n = 6;
|
|
dims = 0;
|
|
char c = ' ';
|
|
while (n < ss.length()) {
|
|
c = ss.charAt(n);
|
|
n++;
|
|
if (c == '[') {
|
|
dims++;
|
|
}
|
|
}
|
|
|
|
String css = ss.substring(ss.lastIndexOf('[') + 1);
|
|
Class compC = tc.getComponentType();
|
|
String cs = compC.toString();
|
|
NT = c; /* must be B,S,I,L,F,D, else error */
|
|
if (NT == 'B') {
|
|
NTsize = 1;
|
|
}
|
|
else if (NT == 'S') {
|
|
NTsize = 2;
|
|
}
|
|
else if ((NT == 'I') || (NT == 'F')) {
|
|
NTsize = 4;
|
|
}
|
|
else if ((NT == 'J') || (NT == 'D')) {
|
|
NTsize = 8;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Byte")) {
|
|
NT = 'L';
|
|
className = "java.lang.Byte";
|
|
NTsize = 1;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Short")) {
|
|
NT = 'L';
|
|
className = "java.lang.Short";
|
|
NTsize = 2;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Integer")) {
|
|
NT = 'L';
|
|
className = "java.lang.Integer";
|
|
NTsize = 4;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Float")) {
|
|
NT = 'L';
|
|
className = "java.lang.Float";
|
|
NTsize = 4;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Double")) {
|
|
NT = 'L';
|
|
className = "java.lang.Double";
|
|
NTsize = 8;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.Long")) {
|
|
NT = 'L';
|
|
className = "java.lang.Long";
|
|
NTsize = 8;
|
|
}
|
|
else if (css.startsWith("Ljava.lang.String")) {
|
|
NT = 'L';
|
|
className = "java.lang.String";
|
|
NTsize = 1;
|
|
throw new HDF5JavaException(
|
|
new String("ArrayDesciptor: Warning: String array not fully supported yet"));
|
|
}
|
|
else {
|
|
/*
|
|
* exception: not a numeric type
|
|
*/
|
|
throw new HDF5JavaException(
|
|
new String("ArrayDesciptor: Error: array is not numeric (type is " + css + ") ?"));
|
|
}
|
|
|
|
/* fill in the table */
|
|
dimlen = new int[dims + 1];
|
|
dimstart = new int[dims + 1];
|
|
currentindex = new int[dims + 1];
|
|
bytetoindex = new int[dims + 1];
|
|
objs = new Object[dims + 1];
|
|
|
|
Object o = anArray;
|
|
objs[0] = o;
|
|
dimlen[0] = 1;
|
|
dimstart[0] = 0;
|
|
currentindex[0] = 0;
|
|
int elements = 1;
|
|
int i;
|
|
for (i = 1; i <= dims; i++) {
|
|
dimlen[i] = java.lang.reflect.Array.getLength((Object)o);
|
|
o = java.lang.reflect.Array.get((Object)o, 0);
|
|
objs[i] = o;
|
|
dimstart[i] = 0;
|
|
currentindex[i] = 0;
|
|
elements *= dimlen[i];
|
|
}
|
|
totalElements = elements;
|
|
|
|
int j;
|
|
int dd;
|
|
bytetoindex[dims] = NTsize;
|
|
for (i = dims; i >= 0; i--) {
|
|
dd = NTsize;
|
|
for (j = i; j < dims; j++) {
|
|
dd *= dimlen[j + 1];
|
|
}
|
|
bytetoindex[i] = dd;
|
|
}
|
|
|
|
totalSize = bytetoindex[0];
|
|
}
|
|
|
|
/**
|
|
* Debug dump
|
|
*/
|
|
public void dumpInfo()
|
|
{
|
|
System.out.println("Type: " + theType);
|
|
System.out.println("Class: " + theClass);
|
|
System.out.println("NT: " + NT + " NTsize: " + NTsize);
|
|
System.out.println("Array has " + dims + " dimensions (" + totalSize + " bytes, " + totalElements +
|
|
" elements)");
|
|
int i;
|
|
for (i = 0; i <= dims; i++) {
|
|
Class tc = objs[i].getClass();
|
|
String ss = tc.toString();
|
|
System.out.println(i + ": start " + dimstart[i] + ": len " + dimlen[i] + " current " +
|
|
currentindex[i] + " bytetoindex " + bytetoindex[i] + " object " + objs[i] +
|
|
" otype " + ss);
|
|
}
|
|
}
|
|
}
|