summaryrefslogtreecommitdiffstats
path: root/java/src/hdf/hdf5lib/HDFNativeData.java
diff options
context:
space:
mode:
Diffstat (limited to 'java/src/hdf/hdf5lib/HDFNativeData.java')
-rw-r--r--java/src/hdf/hdf5lib/HDFNativeData.java481
1 files changed, 481 insertions, 0 deletions
diff --git a/java/src/hdf/hdf5lib/HDFNativeData.java b/java/src/hdf/hdf5lib/HDFNativeData.java
new file mode 100644
index 0000000..66929fb
--- /dev/null
+++ b/java/src/hdf/hdf5lib/HDFNativeData.java
@@ -0,0 +1,481 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 class encapsulates native methods to deal with arrays of numbers,
+ * converting from numbers to bytes and bytes to numbers.
+ * <p>
+ * These routines are used by class <b>HDFArray</b> to pass data to and from the
+ * HDF-5 library.
+ * <p>
+ * Methods xxxToByte() convert a Java array of primitive numbers (int, short,
+ * ...) to a Java array of bytes. Methods byteToXxx() convert from a Java array
+ * of bytes into a Java array of primitive numbers (int, short, ...)
+ * <p>
+ * Variant interfaces convert a section of an array, and also can convert to
+ * sub-classes of Java <b>Number</b>.
+ * <P>
+ * <b>See also:</b> hdf.hdf5lib.HDFArray.
+ */
+
+public class HDFNativeData {
+
+ /**
+ * Convert an array of bytes into an array of ints
+ *
+ * @param data
+ * The input array of bytes
+ * @return an array of int
+ */
+ public synchronized static native int[] byteToInt(byte[] data);
+
+ /**
+ * Convert an array of bytes into an array of floats
+ *
+ * @param data
+ * The input array of bytes
+ * @return an array of float
+ */
+ public synchronized static native float[] byteToFloat(byte[] data);
+
+ /**
+ * Convert an array of bytes into an array of shorts
+ *
+ * @param data
+ * The input array of bytes
+ * @return an array of short
+ */
+ public synchronized static native short[] byteToShort(byte[] data);
+
+ /**
+ * Convert an array of bytes into an array of long
+ *
+ * @param data
+ * The input array of bytes
+ * @return an array of long
+ */
+ /*
+ * does this really work? C 'long' is 32 bits, Java 'long' is 64-bits. What
+ * does this routine actually do?
+ */
+ public synchronized static native long[] byteToLong(byte[] data);
+
+ /**
+ * Convert an array of bytes into an array of double
+ *
+ * @param data
+ * The input array of bytes
+ * @return an array of double
+ */
+ public synchronized static native double[] byteToDouble(byte[] data);
+
+ /**
+ * Convert a range from an array of bytes into an array of int
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param len
+ * The number of 'int' to convert
+ * @param data
+ * The input array of bytes
+ * @return an array of 'len' int
+ */
+ public synchronized static native int[] byteToInt(int start, int len,
+ byte[] data);
+
+ /**
+ * Convert 4 bytes from an array of bytes into a single int
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param data
+ * The input array of bytes
+ * @return The integer value of the bytes.
+ */
+ public synchronized static int byteToInt(byte[] data, int start) {
+ int[] ival = new int[1];
+ ival = byteToInt(start, 1, data);
+ return (ival[0]);
+ }
+
+ /**
+ * Convert a range from an array of bytes into an array of short
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param len
+ * The number of 'short' to convert
+ * @param data
+ * The input array of bytes
+ * @return an array of 'len' short
+ */
+ public synchronized static native short[] byteToShort(int start, int len,
+ byte[] data);
+
+ /**
+ * Convert 2 bytes from an array of bytes into a single short
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param data
+ * The input array of bytes
+ * @return The short value of the bytes.
+ */
+ public synchronized static short byteToShort(byte[] data, int start) {
+ short[] sval = new short[1];
+ sval = byteToShort(start, 1, data);
+ return (sval[0]);
+ }
+
+ /**
+ * Convert a range from an array of bytes into an array of float
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param len
+ * The number of 'float' to convert
+ * @param data
+ * The input array of bytes
+ * @return an array of 'len' float
+ */
+ public synchronized static native float[] byteToFloat(int start, int len,
+ byte[] data);
+
+ /**
+ * Convert 4 bytes from an array of bytes into a single float
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param data
+ * The input array of bytes
+ * @return The float value of the bytes.
+ */
+ public synchronized static float byteToFloat(byte[] data, int start) {
+ float[] fval = new float[1];
+ fval = byteToFloat(start, 1, data);
+ return (fval[0]);
+ }
+
+ /**
+ * Convert a range from an array of bytes into an array of long
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param len
+ * The number of 'long' to convert
+ * @param data
+ * The input array of bytes
+ * @return an array of 'len' long
+ */
+ public synchronized static native long[] byteToLong(int start, int len,
+ byte[] data);
+
+ /**
+ * Convert 8 bytes from an array of bytes into a single long
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param data
+ * The input array of bytes
+ * @return The long value of the bytes.
+ */
+ public synchronized static long byteToLong(byte[] data, int start) {
+ long[] lval = new long[1];
+ lval = byteToLong(start, 1, data);
+ return (lval[0]);
+ }
+
+ /**
+ * Convert a range from an array of bytes into an array of double
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param len
+ * The number of 'double' to convert
+ * @param data
+ * The input array of bytes
+ * @return an array of 'len' double
+ */
+ public synchronized static native double[] byteToDouble(int start, int len,
+ byte[] data);
+
+ /**
+ * Convert 8 bytes from an array of bytes into a single double
+ *
+ * @param start
+ * The position in the input array of bytes to start
+ * @param data
+ * The input array of bytes
+ * @return The double value of the bytes.
+ */
+ public synchronized static double byteToDouble(byte[] data, int start) {
+ double[] dval = new double[1];
+ dval = byteToDouble(start, 1, data);
+ return (dval[0]);
+ }
+
+ /**
+ * Convert a range from an array of int into an array of bytes.
+ *
+ * @param start
+ * The position in the input array of int to start
+ * @param len
+ * The number of 'int' to convert
+ * @param data
+ * The input array of int
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] intToByte(int start, int len,
+ int[] data);
+
+ /**
+ * Convert a range from an array of short into an array of bytes.
+ *
+ * @param start
+ * The position in the input array of int to start
+ * @param len
+ * The number of 'short' to convert
+ * @param data
+ * The input array of short
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] shortToByte(int start, int len,
+ short[] data);
+
+ /**
+ * Convert a range from an array of float into an array of bytes.
+ *
+ * @param start
+ * The position in the input array of int to start
+ * @param len
+ * The number of 'float' to convert
+ * @param data
+ * The input array of float
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] floatToByte(int start, int len,
+ float[] data);
+
+ /**
+ * Convert a range from an array of long into an array of bytes.
+ *
+ * @param start
+ * The position in the input array of int to start
+ * @param len
+ * The number of 'long' to convert
+ * @param data
+ * The input array of long
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] longToByte(int start, int len,
+ long[] data);
+
+ /**
+ * Convert a range from an array of double into an array of bytes.
+ *
+ * @param start
+ * The position in the input array of double to start
+ * @param len
+ * The number of 'double' to convert
+ * @param data
+ * The input array of double
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] doubleToByte(int start, int len,
+ double[] data);
+
+ /**
+ * Convert a single byte into an array of one byte.
+ * <p>
+ * (This is a trivial method.)
+ *
+ * @param data
+ * The input byte
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] byteToByte(byte data);
+
+ /**
+ * Convert a single Byte object into an array of one byte.
+ * <p>
+ * (This is an almost trivial method.)
+ *
+ * @param data
+ * The input Byte
+ * @return an array of bytes
+ */
+ public synchronized static byte[] byteToByte(Byte data) {
+ return byteToByte(data.byteValue());
+ }
+
+ /**
+ * Convert a single int into an array of 4 bytes.
+ *
+ * @param data
+ * The input int
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] intToByte(int data);
+
+ /**
+ * Convert a single Integer object into an array of 4 bytes.
+ *
+ * @param data
+ * The input Integer
+ * @return an array of bytes
+ */
+ public synchronized static byte[] intToByte(Integer data) {
+ return intToByte(data.intValue());
+ }
+
+ /**
+ * Convert a single short into an array of 2 bytes.
+ *
+ * @param data
+ * The input short
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] shortToByte(short data);
+
+ /**
+ * Convert a single Short object into an array of 2 bytes.
+ *
+ * @param data
+ * The input Short
+ * @return an array of bytes
+ */
+ public synchronized static byte[] shortToByte(Short data) {
+ return shortToByte(data.shortValue());
+ }
+
+ /**
+ * Convert a single float into an array of 4 bytes.
+ *
+ * @param data
+ * The input float
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] floatToByte(float data);
+
+ /**
+ * Convert a single Float object into an array of 4 bytes.
+ *
+ * @param data
+ * The input Float
+ * @return an array of bytes
+ */
+ public synchronized static byte[] floatToByte(Float data) {
+ return floatToByte(data.floatValue());
+ };
+
+ /**
+ * Convert a single long into an array of 8 bytes.
+ *
+ * @param data
+ * The input long
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] longToByte(long data);
+
+ /**
+ * Convert a single Long object into an array of 8 bytes.
+ *
+ * @param data
+ * The input Long
+ * @return an array of bytes
+ */
+ public synchronized static byte[] longToByte(Long data) {
+ return longToByte(data.longValue());
+ }
+
+ /**
+ * Convert a single double into an array of 8 bytes.
+ *
+ * @param data
+ * The input double
+ * @return an array of bytes
+ */
+ public synchronized static native byte[] doubleToByte(double data);
+
+ /**
+ * Convert a single Double object into an array of 8 bytes.
+ *
+ * @param data
+ * The input Double
+ * @return an array of bytes
+ */
+ public synchronized static byte[] doubleToByte(Double data) {
+ return doubleToByte(data.doubleValue());
+ }
+
+ /**
+ * Create a Number object from an array of bytes.
+ *
+ * @param barray
+ * The bytes to be converted
+ * @param obj
+ * Input object of the desired output class. Must be a sub-class
+ * of Number.
+ * @return A Object of the type of obj.
+ *
+ * @exception HDF5Exception
+ * - Error unsupported type.
+ */
+ public synchronized static Object byteToNumber(byte[] barray, Object obj)
+ throws HDF5Exception {
+ Class theClass = obj.getClass();
+ String type = theClass.getName();
+ Object retobj = null;
+
+ if (type.equals("java.lang.Integer")) {
+ int[] i = hdf.hdf5lib.HDFNativeData.byteToInt(0, 1, barray);
+ retobj = new Integer(i[0]);
+ }
+ else if (type.equals("java.lang.Byte")) {
+ retobj = new Byte(barray[0]);
+ }
+ else if (type.equals("java.lang.Short")) {
+ short[] f = hdf.hdf5lib.HDFNativeData
+ .byteToShort(0, 1, barray);
+ retobj = new Short(f[0]);
+ }
+ else if (type.equals("java.lang.Float")) {
+ float[] f = hdf.hdf5lib.HDFNativeData
+ .byteToFloat(0, 1, barray);
+ retobj = new Float(f[0]);
+ }
+ else if (type.equals("java.lang.Long")) {
+ long[] f = hdf.hdf5lib.HDFNativeData.byteToLong(0, 1, barray);
+ retobj = new Long(f[0]);
+ }
+ else if (type.equals("java.lang.Double")) {
+ double[] f = hdf.hdf5lib.HDFNativeData.byteToDouble(0, 1,
+ barray);
+ retobj = new Double(f[0]);
+ }
+ else {
+ /* exception: unsupported type */
+ HDF5Exception ex = new HDF5JavaException(
+ "byteToNumber: setfield bad type: " + obj + " " + type);
+ throw (ex);
+ }
+ return (retobj);
+ }
+}