diff options
author | Allen Byrne <byrn@hdfgroup.org> | 2016-02-29 02:43:00 (GMT) |
---|---|---|
committer | Allen Byrne <byrn@hdfgroup.org> | 2016-02-29 02:43:00 (GMT) |
commit | 63249be0e10a8726acb5a7cf64491319eaa46227 (patch) | |
tree | ebb2b75ece8852e8a58804631c0004f06a9bba9f /java/src/hdf/hdf5lib/HDFArray.java | |
parent | a1617b7cdbe14173fcf690b4627059fa4528c19b (diff) | |
download | hdf5-63249be0e10a8726acb5a7cf64491319eaa46227.zip hdf5-63249be0e10a8726acb5a7cf64491319eaa46227.tar.gz hdf5-63249be0e10a8726acb5a7cf64491319eaa46227.tar.bz2 |
[svn-r29226] HDFFV-9552: merge in java code.
Diffstat (limited to 'java/src/hdf/hdf5lib/HDFArray.java')
-rw-r--r-- | java/src/hdf/hdf5lib/HDFArray.java | 1096 |
1 files changed, 1096 insertions, 0 deletions
diff --git a/java/src/hdf/hdf5lib/HDFArray.java b/java/src/hdf/hdf5lib/HDFArray.java new file mode 100644 index 0000000..55c19e4 --- /dev/null +++ b/java/src/hdf/hdf5lib/HDFArray.java @@ -0,0 +1,1096 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * Copyright by The HDF Group. * + * Copyright by the Board of Trustees of the University of Illinois. * + * 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 files COPYING and Copyright.html. COPYING can be found at the root * + * of the source code distribution tree; Copyright.html can be found at the * + * root level of an installed copy of the electronic HDF5 document set and * + * is linked from the top-level documents page. It can also be found at * + * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have * + * access to either file, you may request a copy from help@hdfgroup.org. * + * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ + + +package hdf.hdf5lib; + +import hdf.hdf5lib.exceptions.HDF5Exception; +import hdf.hdf5lib.exceptions.HDF5JavaException; + +/** + * 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 <a + * href="./hdf.hdf5lib.HDFNativeData.html">HDFNativeData</a> 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.HDF5Exception + * object is not an array. + */ + public HDFArray(Object anArray) throws HDF5Exception { + + 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]); + 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 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)) { + 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 { + if (ArrayDescriptor.NT == 'J') { + long[] arow = HDFNativeData.byteToLong(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + 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]++; + } + else if (ArrayDescriptor.NT == 'I') { + int[] arow = HDFNativeData.byteToInt(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + 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]++; + } + else if (ArrayDescriptor.NT == 'S') { + short[] arow = HDFNativeData.byteToShort(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + 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]++; + } + else if (ArrayDescriptor.NT == 'B') { + System.arraycopy(_barray, n, + ArrayDescriptor.objs[ArrayDescriptor.dims - 1], 0, + ArrayDescriptor.dimlen[ArrayDescriptor.dims]); + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + } + else if (ArrayDescriptor.NT == 'F') { + float arow[] = HDFNativeData.byteToFloat(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + 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]++; + } + else if (ArrayDescriptor.NT == 'D') { + double[] arow = HDFNativeData.byteToDouble(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + 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]++; + } + else if (ArrayDescriptor.NT == 'L') { + if (ArrayDescriptor.className.equals("java.lang.Byte")) { + Byte I[] = ByteToByteObj(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else if (ArrayDescriptor.className + .equals("java.lang.Integer")) { + Integer I[] = ByteToInteger(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else if (ArrayDescriptor.className + .equals("java.lang.Short")) { + Short I[] = ByteToShort(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else if (ArrayDescriptor.className + .equals("java.lang.Float")) { + Float I[] = ByteToFloatObj(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else if (ArrayDescriptor.className + .equals("java.lang.Double")) { + Double I[] = ByteToDoubleObj(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else if (ArrayDescriptor.className.equals("java.lang.Long")) { + Long I[] = ByteToLongObj(n, + ArrayDescriptor.dimlen[ArrayDescriptor.dims], + _barray); + java.lang.reflect.Array + .set( + ArrayDescriptor.objs[ArrayDescriptor.dims - 2], + (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]), + I); + + n += ArrayDescriptor.bytetoindex[ArrayDescriptor.dims - 1]; + ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1]++; + } + else { + HDF5JavaException ex = new HDF5JavaException( + "HDFArray: unsupported Object type: " + + ArrayDescriptor.NT); + throw (ex); + } + } + else { + HDF5JavaException ex = new HDF5JavaException( + "HDFArray: unknown or unsupported type: " + + ArrayDescriptor.NT); + throw (ex); + } + } + 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.NT != 'B') { + 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]) + + "?")); + } + } + else { + if (ArrayDescriptor.currentindex[ArrayDescriptor.dims - 1] != (ArrayDescriptor.dimlen[ArrayDescriptor.dims - 1] - 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) + "?")); + } + } + + 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] = new Integer(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] = new Integer(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] = new Short(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] = new Short(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] = new Byte(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] = new Byte(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] = new Float(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] = new Float(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] = new Double(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] = new Double(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] = new Long(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] = new Long(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 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 HDF5Exception { + + Class tc = anArray.getClass(); + if (tc.isArray() == false) { + /* exception: not an array */ + HDF5Exception 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")) { + throw new HDF5JavaException(new String( + "ArrayDesciptor: Error: String array not 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 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; + } + + 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)"); + 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); + } + } +} |