1 10 Fix java data export functions (#450)

* HDFFV-10865 - merge from dev, HDFArray perf fix.

* Remove duplicate setting

* Whitespace changes after clang format

* Undo version 11 clang format changes

* Merge CMake changes from develop

* test testing script merge from develop

* Update supported platforms

* PR#3 merge from develop

* Merge gcc 10 diagnostics option from develop

* Merge #318 OSX changes from develop

* Merge small changes from develop

* Minor non-space formatting changes

* #386 copyright corrections for java folder

* Merges from develop

#358 patches from vtk
#361 fix header guard spelling

* Merge updates

#358 patches from vtk
#361 fix header guard spelling

* format fix

* Fix missing underscore and make H5public.h closer to dev

* Merges from develop

#340 clang -Wformat-security warnings
#360 Fixed uninitialized warnings
header guard underscore cleanup
JNI cleanup

* format alignment

* Add missing test ref file

* Merge #380 from develop

* Finish java merges from develop

* Fix java issues with tests and javadoc

* Correct use of attribute access plist

* Remove debug code

* Remove unused variable

* Change file access to read only for java tests

* Split clang format operations.

* More javadoc comments

* Remove pre-split setting

* format source

5 files changed, 264 insertions, 307 deletions

diff --git a/java/src/hdf/hdf5lib/H5.java b/java/src/hdf/hdf5lib/H5.java
index 2d0ad76..db9350e 100644
--- a/java/src/hdf/hdf5lib/H5.java
+++ b/java/src/hdf/hdf5lib/H5.java
@@ -510,8 +510,8 @@ public class H5 implements java.io.Serializable {
      *
      * @param file_export_name
      *            The file name to export data into.
-     * @param file_name
-     *            The name of the HDF5 file containing the dataset.
+     * @param file_id
+     *            The identifier of the HDF5 file containing the dataset.
      * @param object_path
      *            The full path of the dataset to be exported.
      * @param binary_order
@@ -523,7 +523,28 @@ public class H5 implements java.io.Serializable {
      * @exception HDF5LibraryException
      *                - Error from the HDF-5 Library.
      **/
-    public synchronized static native void H5export_dataset(String file_export_name, String file_name,
+    public synchronized static native void H5export_dataset(String file_export_name, long file_id,
+            String object_path, int binary_order) throws HDF5LibraryException;
+
+    /**
+     * H5export_attribute is a utility function to save data in a file.
+     *
+     * @param file_export_name
+     *            The file name to export data into.
+     * @param dataset_id
+     *            The identifier of the dataset containing the attribute.
+     * @param object_path
+     *            The attribute to be exported.
+     * @param binary_order
+     *            99 - export data as text.
+     *            1 - export data as binary Native Order.
+     *            2 - export data as binary Little Endian.
+     *            3 - export data as binary Big Endian.
+     *
+     * @exception HDF5LibraryException
+     *                - Error from the HDF-5 Library.
+     **/
+    public synchronized static native void H5export_attribute(String file_export_name, long dataset_id,
             String object_path, int binary_order) throws HDF5LibraryException;
 
     /**
diff --git a/java/src/hdf/hdf5lib/HDF5Constants.java b/java/src/hdf/hdf5lib/HDF5Constants.java
index 5f72aee..ad9ed70 100644
--- a/java/src/hdf/hdf5lib/HDF5Constants.java
+++ b/java/src/hdf/hdf5lib/HDF5Constants.java
@@ -45,14 +45,23 @@ public class HDF5Constants {
     public static final int H5_SZIP_ALLOW_K13_OPTION_MASK = H5_SZIP_ALLOW_K13_OPTION_MASK();
     /** Special parameters for szip compression */
     public static final int H5_SZIP_CHIP_OPTION_MASK = H5_SZIP_CHIP_OPTION_MASK();
+    /** indices on links, unknown index type */
     public static final int H5_INDEX_UNKNOWN = H5_INDEX_UNKNOWN();
+    /** indices on links, index on names */
     public static final int H5_INDEX_NAME = H5_INDEX_NAME();
+    /** indices on links, index on creation order */
     public static final int H5_INDEX_CRT_ORDER = H5_INDEX_CRT_ORDER();
+    /** indices on links, number of indices defined */
     public static final int H5_INDEX_N = H5_INDEX_N();
+    /** Common iteration orders, Unknown order */
     public static final int H5_ITER_UNKNOWN = H5_ITER_UNKNOWN();
+    /** Common iteration orders, Increasing order */
     public static final int H5_ITER_INC = H5_ITER_INC();
+    /** Common iteration orders, Decreasing order */
     public static final int H5_ITER_DEC = H5_ITER_DEC();
+    /** Common iteration orders, No particular order, whatever is fastest */
     public static final int H5_ITER_NATIVE = H5_ITER_NATIVE();
+    /** Common iteration orders, Number of iteration orders */
     public static final int H5_ITER_N = H5_ITER_N();
     public static final int H5AC_CURR_CACHE_CONFIG_VERSION = H5AC_CURR_CACHE_CONFIG_VERSION();
     public static final int H5AC_MAX_TRACE_FILE_NAME_LEN = H5AC_MAX_TRACE_FILE_NAME_LEN();
diff --git a/java/src/hdf/hdf5lib/HDF5GroupInfo.java b/java/src/hdf/hdf5lib/HDF5GroupInfo.java
index 44b41bb..4c31af7 100644
--- a/java/src/hdf/hdf5lib/HDF5GroupInfo.java
+++ b/java/src/hdf/hdf5lib/HDF5GroupInfo.java
@@ -41,6 +41,8 @@ public class HDF5GroupInfo {
     long mtime;
     int linklen;
 
+    /** Container for the information reported about an HDF5 Object
+      * from the H5Gget_obj_info() method */
     public HDF5GroupInfo() {
         fileno = new long[2];
         objno = new long[2];
@@ -88,27 +90,44 @@ public class HDF5GroupInfo {
         linklen = 0;
     }
 
-    /* accessors */
+    /** fileno accessors
+     * @return the file number if successful
+     */
     public long[] getFileno() {
         return fileno;
     }
 
+    /** accessors
+     * @return the object number if successful
+     */
     public long[] getObjno() {
         return objno;
     }
 
+    /** accessors
+     * @return type of group if successful
+     */
     public int getType() {
         return type;
     }
 
+    /** accessors
+     * @return the number of links in the group if successful
+     */
     public int getNlink() {
         return nlink;
     }
 
+    /** accessors
+     * @return the modified time value if successful
+     */
     public long getMtime() {
         return mtime;
     }
 
+    /** accessors
+     * @return a length of link name if successful
+     */
     public int getLinklen() {
         return linklen;
     }
diff --git a/java/src/hdf/hdf5lib/HDFArray.java b/java/src/hdf/hdf5lib/HDFArray.java
index 96291b3..bb9357e 100644
--- a/java/src/hdf/hdf5lib/HDFArray.java
+++ b/java/src/hdf/hdf5lib/HDFArray.java
@@ -20,19 +20,16 @@ import java.util.Arrays;
 /**
  * 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.
+ * 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.
+ * 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.
+ * 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;
@@ -40,31 +37,27 @@ public class HDFArray {
     // public HDFArray() {}
 
     /**
-     * The input must be a Java Array (possibly multidimensional) of primitive
-     * numbers or sub-classes of Number.
+     * 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.
+     * 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.
-     *
+     *                The array object.
      * @exception hdf.hdf5lib.exceptions.HDF5Exception
-     *                object is not an array.
+     *                                                 object is not an array.
      */
-    public HDFArray(Object anArray) throws HDF5Exception {
-
+    public HDFArray(Object anArray) throws HDF5Exception
+    {
         if (anArray == null) {
-            HDF5JavaException ex = new HDF5JavaException(
-                    "HDFArray: array is 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?: ");
+            HDF5JavaException ex = new HDF5JavaException("HDFArray: not an array?: ");
             throw (ex);
         }
         _theArray = anArray;
@@ -72,8 +65,7 @@ public class HDFArray {
 
         /* extra error checking -- probably not needed */
         if (_desc == null) {
-            HDF5JavaException ex = new HDF5JavaException(
-                    "HDFArray: internal error: array description failed?: ");
+            HDF5JavaException ex = new HDF5JavaException("HDFArray: internal error: array description failed?: ");
             throw (ex);
         }
     }
@@ -81,49 +73,48 @@ public class HDFArray {
     /**
      * 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.
+     * @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.
+     *                                                     Allocation failed.
      */
 
-    public byte[] emptyBytes() throws HDF5JavaException {
+    public byte[] emptyBytes()
+            throws HDF5JavaException
+    {
         byte[] b = null;
 
-        if ((ArrayDescriptor.dims == 1) && (ArrayDescriptor.NT == 'B')) {
+        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");
+            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.
+     * 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.
+     * @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.
+     *                                                     the object not an array or other internal error.
      */
-    public byte[] byteify() throws HDF5JavaException {
-
+    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?: ");
+            HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify not an array?: ");
             throw (ex);
         }
 
@@ -140,73 +131,53 @@ public class HDFArray {
 
                     byte[] therow;
                     if (ArrayDescriptor.NT == 'I') {
-                        therow = HDFNativeData.intToByte(0,
-                                ArrayDescriptor.dimlen[1], (int[]) _theArray);
+                        therow = HDFNativeData.intToByte(0, ArrayDescriptor.dimlen[1], (int[]) _theArray);
                     }
                     else if (ArrayDescriptor.NT == 'S') {
-                        therow = HDFNativeData.shortToByte(0,
-                                ArrayDescriptor.dimlen[1], (short[]) _theArray);
+                        therow = HDFNativeData.shortToByte(0, ArrayDescriptor.dimlen[1], (short[]) _theArray);
                     }
                     else if (ArrayDescriptor.NT == 'F') {
-                        therow = HDFNativeData.floatToByte(0,
-                                ArrayDescriptor.dimlen[1], (float[]) _theArray);
+                        therow = HDFNativeData.floatToByte(0, ArrayDescriptor.dimlen[1], (float[]) _theArray);
                     }
                     else if (ArrayDescriptor.NT == 'J') {
-                        therow = HDFNativeData.longToByte(0,
-                                ArrayDescriptor.dimlen[1], (long[]) _theArray);
+                        therow = HDFNativeData.longToByte(0, ArrayDescriptor.dimlen[1], (long[]) _theArray);
                     }
                     else if (ArrayDescriptor.NT == 'D') {
-                        therow = HDFNativeData
-                                .doubleToByte(0, ArrayDescriptor.dimlen[1],
-                                        (double[]) _theArray);
+                        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")) {
+                        else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
                             therow = IntegerToByte((Integer[]) _theArray);
                         }
-                        else if (ArrayDescriptor.className
-                                .equals("java.lang.Short")) {
+                        else if (ArrayDescriptor.className.equals("java.lang.Short")) {
                             therow = ShortToByte((Short[]) _theArray);
                         }
-                        else if (ArrayDescriptor.className
-                                .equals("java.lang.Float")) {
+                        else if (ArrayDescriptor.className.equals("java.lang.Float")) {
                             therow = FloatObjToByte((Float[]) _theArray);
                         }
-                        else if (ArrayDescriptor.className
-                                .equals("java.lang.Double")) {
+                        else if (ArrayDescriptor.className.equals("java.lang.Double")) {
                             therow = DoubleObjToByte((Double[]) _theArray);
                         }
-                        else if (ArrayDescriptor.className
-                                .equals("java.lang.Long")) {
+                        else if (ArrayDescriptor.className.equals("java.lang.Long")) {
                             therow = LongObjToByte((Long[]) _theArray);
                         }
                         else {
-                            HDF5JavaException ex = new HDF5JavaException(
-                                    "HDFArray: unknown type of Object?");
+                            HDF5JavaException ex = new HDF5JavaException("HDFArray: unknown type of Object?");
                             throw (ex);
                         }
                     }
                     else {
-                        HDF5JavaException ex = new HDF5JavaException(
-                                "HDFArray: unknown type of data?");
+                        HDF5JavaException ex = new HDF5JavaException("HDFArray: unknown type of data?");
                         throw (ex);
                     }
-                    System
-                            .arraycopy(
-                                    therow,
-                                    0,
-                                    _barray,
-                                    0,
-                                    (ArrayDescriptor.dimlen[1] * ArrayDescriptor.NTsize));
+                    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?");
+                    HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify array too big?");
                     throw (ex);
                 }
             }
@@ -216,8 +187,7 @@ public class HDFArray {
             _barray = new byte[ArrayDescriptor.totalSize];
         }
         catch (OutOfMemoryError err) {
-            HDF5JavaException ex = new HDF5JavaException(
-                    "HDFArray: byteify array too big?");
+            HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify array too big?");
             throw (ex);
         }
 
@@ -240,8 +210,7 @@ public class HDFArray {
                 else {
                     /* check range of index */
                     if (index > (ArrayDescriptor.dimlen[i] - 1)) {
-                        throw new java.lang.IndexOutOfBoundsException(
-                                "HDFArray: byteify index OOB?");
+                        throw new java.lang.IndexOutOfBoundsException("HDFArray: byteify index OOB?");
                     }
                     oo = java.lang.reflect.Array.get(oo, index);
                     ArrayDescriptor.currentindex[i] = index;
@@ -253,144 +222,107 @@ public class HDFArray {
             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]);
+                    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]);
+                    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]);
+                    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]);
+                    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]);
+                    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")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
                         arow = IntegerToByte((Integer[]) ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Short")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Short")) {
                         arow = ShortToByte((Short[]) ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Float")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Float")) {
                         arow = FloatObjToByte((Float[]) ArrayDescriptor.objs[ArrayDescriptor.dims - 1]);
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Double")) {
+                    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?");
+                        HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify Object type not implemented?");
                         throw (ex);
                     }
                 }
                 else {
-                    HDF5JavaException ex = new HDF5JavaException(
-                            "HDFArray: byteify unknown type not implemented?");
+                    HDF5JavaException ex = new HDF5JavaException("HDFArray: byteify unknown type not implemented?");
                     throw (ex);
                 }
-                System
-                        .arraycopy(
-                                arow,
-                                0,
-                                _barray,
-                                n,
-                                (ArrayDescriptor.dimlen[ArrayDescriptor.dims] * ArrayDescriptor.NTsize));
+                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?");
+                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));
+            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) + " ?)"));
+                        "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.
+     * 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.
+     *              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 {
-
+    public Object arrayify(byte[] bytes) throws HDF5JavaException
+    {
         if (_theArray == null) {
             /* exception: not an array */
-            HDF5JavaException ex = new HDF5JavaException(
-                    "arrayify: 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?: ");
+            HDF5JavaException ex = new HDF5JavaException("arrayify: array is wrong size?: ");
             throw (ex);
         }
         _barray = bytes; /* hope that the bytes are correct.... */
@@ -401,95 +333,76 @@ public class HDFArray {
             try {
                 if (ArrayDescriptor.NT == 'I') {
                     int[] x = HDFNativeData.byteToInt(_barray);
-                    System.arraycopy(x, 0, _theArray, 0,
-                            ArrayDescriptor.dimlen[1]);
+                    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]);
+                    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]);
+                    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]);
+                    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]);
+                    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]);
+                    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]);
+                        System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
                         return _theArray;
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Integer")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Integer")) {
                         Integer I[] = ByteToInteger(_barray);
-                        System.arraycopy(I, 0, _theArray, 0,
-                                ArrayDescriptor.dimlen[1]);
+                        System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
                         return _theArray;
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Short")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Short")) {
                         Short I[] = ByteToShort(_barray);
-                        System.arraycopy(I, 0, _theArray, 0,
-                                ArrayDescriptor.dimlen[1]);
+                        System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
                         return _theArray;
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Float")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Float")) {
                         Float I[] = ByteToFloatObj(_barray);
-                        System.arraycopy(I, 0, _theArray, 0,
-                                ArrayDescriptor.dimlen[1]);
+                        System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
                         return _theArray;
                     }
-                    else if (ArrayDescriptor.className
-                            .equals("java.lang.Double")) {
+                    else if (ArrayDescriptor.className.equals("java.lang.Double")) {
                         Double I[] = ByteToDoubleObj(_barray);
-                        System.arraycopy(I, 0, _theArray, 0,
-                                ArrayDescriptor.dimlen[1]);
+                        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]);
+                        System.arraycopy(I, 0, _theArray, 0, ArrayDescriptor.dimlen[1]);
                         return _theArray;
                     }
                     else {
-                        HDF5JavaException ex = new HDF5JavaException(
-                                "arrayify:  Object type not implemented yet...");
+                        HDF5JavaException ex = new HDF5JavaException("arrayify:  Object type not implemented yet...");
                         throw (ex);
                     }
                 }
                 else {
-                    HDF5JavaException ex = new HDF5JavaException(
-                            "arrayify:  unknown type not implemented yet...");
+                    HDF5JavaException ex = new HDF5JavaException("arrayify:  unknown type not implemented yet...");
                     throw (ex);
                 }
             }
             catch (OutOfMemoryError err) {
-                HDF5JavaException ex = new HDF5JavaException(
-                        "HDFArray: arrayify array too big?");
+                HDF5JavaException ex = new HDF5JavaException("HDFArray: arrayify array too big?");
                 throw (ex);
             }
         }
@@ -501,6 +414,7 @@ public class HDFArray {
         int index = 0;
         int i;
         Object flattenedArray = null;
+
         switch (ArrayDescriptor.NT) {
         case 'J':
             flattenedArray = (Object) HDFNativeData.byteToLong(_barray);
@@ -521,36 +435,27 @@ public class HDFArray {
             flattenedArray = (Object) _barray;
             break;
         case 'L':
-            switch (ArrayDescriptor.className) {
-            case "java.lang.Byte":
-                flattenedArray = (Object) ByteToByteObj(_barray);
-                break;
-            case "java.lang.Short":
-                flattenedArray = (Object) ByteToShort(_barray);
-                break;
-            case "java.lang.Integer":
-                flattenedArray = (Object) ByteToInteger(_barray);
-                break;
-            case "java.lang.Long":
-                flattenedArray = (Object) ByteToLongObj(_barray);
-                break;
-            case "java.lang.Float":
-                flattenedArray = (Object) ByteToFloatObj(_barray);
-                break;
-            case "java.lang.Double":
-                flattenedArray = (Object) ByteToDoubleObj(_barray);
-                break;
-            default:
-                HDF5JavaException ex = new HDF5JavaException(
-                        "HDFArray: unsupported Object type: "
-                                + ArrayDescriptor.NT);
-                throw (ex);
-            } // end of switch statement for arrays of boxed objects
-            default:
-                HDF5JavaException ex = new HDF5JavaException(
-                        "HDFArray: unknown or unsupported type: "
-                                + ArrayDescriptor.NT);
-                throw (ex);
+            {
+                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);
+                }
+            } // 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) {
@@ -579,7 +484,6 @@ public class HDFArray {
 
             /* array-ify */
             try {
-
                 Object arow = null;
                 int mm = m + ArrayDescriptor.dimlen[ArrayDescriptor.dims];
                 switch (ArrayDescriptor.NT) {
@@ -602,75 +506,64 @@ public class HDFArray {
                     arow = (Object) Arrays.copyOfRange((double[]) flattenedArray, m, mm);
                     break;
                 case 'L':
-                    switch (ArrayDescriptor.className) {
-                    case "java.lang.Byte":
-                        arow = (Object) Arrays.copyOfRange((Byte[])flattenedArray, m, mm);
-                        break;
-                    case "java.lang.Short":
-                        arow = (Object) Arrays.copyOfRange((Short[])flattenedArray, m, mm);
-                        break;
-                    case "java.lang.Integer":
-                        arow = (Object) Arrays.copyOfRange((Integer[])flattenedArray, m, mm);
-                        break;
-                    case "java.lang.Long":
-                        arow = (Object) Arrays.copyOfRange((Long[])flattenedArray, m, mm);
-                        break;
-                    case "java.lang.Float":
-                        arow = (Object) Arrays.copyOfRange((Float[])flattenedArray, m, mm);
-                        break;
-                    case "java.lang.Double":
-                        arow = (Object) Arrays.copyOfRange((Double[])flattenedArray, m, mm);
-                        break;
-                    } // end of switch statement for arrays of boxed numerics
+                    {
+                        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);
+                        }
+                    } // 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);
+                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?");
+                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));
+            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) + "?"));
+                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])
-                                    + "?"));
+        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[]) {
+    private byte[] IntegerToByte(Integer in[])
+    {
         int nelems = java.lang.reflect.Array.getLength(in);
         int[] out = new int[nelems];
 
@@ -680,7 +573,8 @@ public class HDFArray {
         return HDFNativeData.intToByte(0, nelems, out);
     }
 
-    private Integer[] ByteToInteger(byte[] bin) {
+    private Integer[] ByteToInteger(byte[] bin)
+    {
         int in[] = HDFNativeData.byteToInt(bin);
         int nelems = java.lang.reflect.Array.getLength(in);
         Integer[] out = new Integer[nelems];
@@ -691,7 +585,8 @@ public class HDFArray {
         return out;
     }
 
-    private Integer[] ByteToInteger(int start, int len, byte[] bin) {
+    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];
@@ -702,7 +597,8 @@ public class HDFArray {
         return out;
     }
 
-    private byte[] ShortToByte(Short in[]) {
+    private byte[] ShortToByte(Short in[])
+    {
         int nelems = java.lang.reflect.Array.getLength(in);
         short[] out = new short[nelems];
 
@@ -712,7 +608,8 @@ public class HDFArray {
         return HDFNativeData.shortToByte(0, nelems, out);
     }
 
-    private Short[] ByteToShort(byte[] bin) {
+    private Short[] ByteToShort(byte[] bin)
+    {
         short in[] = HDFNativeData.byteToShort(bin);
         int nelems = java.lang.reflect.Array.getLength((Object) in);
         Short[] out = new Short[nelems];
@@ -723,7 +620,8 @@ public class HDFArray {
         return out;
     }
 
-    private Short[] ByteToShort(int start, int len, byte[] bin) {
+    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];
@@ -734,7 +632,8 @@ public class HDFArray {
         return out;
     }
 
-    private byte[] ByteObjToByte(Byte in[]) {
+    private byte[] ByteObjToByte(Byte in[])
+    {
         int nelems = java.lang.reflect.Array.getLength((Object) in);
         byte[] out = new byte[nelems];
 
@@ -744,7 +643,8 @@ public class HDFArray {
         return out;
     }
 
-    private Byte[] ByteToByteObj(byte[] bin) {
+    private Byte[] ByteToByteObj(byte[] bin)
+    {
         int nelems = java.lang.reflect.Array.getLength((Object) bin);
         Byte[] out = new Byte[nelems];
 
@@ -754,7 +654,8 @@ public class HDFArray {
         return out;
     }
 
-    private Byte[] ByteToByteObj(int start, int len, byte[] bin) {
+    private Byte[] ByteToByteObj(int start, int len, byte[] bin)
+    {
         Byte[] out = new Byte[len];
 
         for (int i = 0; i < len; i++) {
@@ -763,7 +664,8 @@ public class HDFArray {
         return out;
     }
 
-    private byte[] FloatObjToByte(Float in[]) {
+    private byte[] FloatObjToByte(Float in[])
+    {
         int nelems = java.lang.reflect.Array.getLength((Object) in);
         float[] out = new float[nelems];
 
@@ -773,7 +675,8 @@ public class HDFArray {
         return HDFNativeData.floatToByte(0, nelems, out);
     }
 
-    private Float[] ByteToFloatObj(byte[] bin) {
+    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];
@@ -784,7 +687,8 @@ public class HDFArray {
         return out;
     }
 
-    private Float[] ByteToFloatObj(int start, int len, byte[] bin) {
+    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];
@@ -795,7 +699,8 @@ public class HDFArray {
         return out;
     }
 
-    private byte[] DoubleObjToByte(Double in[]) {
+    private byte[] DoubleObjToByte(Double in[])
+    {
         int nelems = java.lang.reflect.Array.getLength((Object) in);
         double[] out = new double[nelems];
 
@@ -805,7 +710,8 @@ public class HDFArray {
         return HDFNativeData.doubleToByte(0, nelems, out);
     }
 
-    private Double[] ByteToDoubleObj(byte[] bin) {
+    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];
@@ -816,7 +722,8 @@ public class HDFArray {
         return out;
     }
 
-    private Double[] ByteToDoubleObj(int start, int len, byte[] bin) {
+    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];
@@ -827,7 +734,8 @@ public class HDFArray {
         return out;
     }
 
-    private byte[] LongObjToByte(Long in[]) {
+    private byte[] LongObjToByte(Long in[])
+    {
         int nelems = java.lang.reflect.Array.getLength((Object) in);
         long[] out = new long[nelems];
 
@@ -837,7 +745,8 @@ public class HDFArray {
         return HDFNativeData.longToByte(0, nelems, out);
     }
 
-    private Long[] ByteToLongObj(byte[] bin) {
+    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];
@@ -848,7 +757,8 @@ public class HDFArray {
         return out;
     }
 
-    private Long[] ByteToLongObj(int start, int len, byte[] bin) {
+    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];
@@ -861,13 +771,11 @@ public class HDFArray {
 }
 
 /**
- * This private class is used by HDFArray to discover the shape and type of an
- * arbitrary array.
+ * 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;
@@ -882,13 +790,12 @@ class ArrayDescriptor {
     static int dims = 0;
     static String className;
 
-    public ArrayDescriptor(Object anArray) throws HDF5Exception {
-
+    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?: ");
+            HDF5Exception ex = new HDF5JavaException("ArrayDescriptor: not an array?: ");
             throw (ex);
         }
 
@@ -960,16 +867,14 @@ class ArrayDescriptor {
             NT = 'L';
             className = "java.lang.String";
             NTsize = 1;
-            throw new HDF5JavaException(new String(
-                    "ArrayDesciptor: Warning:  String array not fully supported yet"));
+            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 + ") ?"));
+            throw new HDF5JavaException(
+                    new String("ArrayDesciptor: Error:  array is not numeric (type is " + css + ") ?"));
         }
 
         /* fill in the table */
@@ -1013,7 +918,8 @@ class ArrayDescriptor {
     /**
      * Debug dump
      */
-    public void dumpInfo() {
+    public void dumpInfo()
+    {
         System.out.println("Type: " + theType);
         System.out.println("Class: " + theClass);
         System.out.println("NT: " + NT + " NTsize: " + NTsize);
@@ -1023,10 +929,8 @@ class ArrayDescriptor {
         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);
+            System.out.println(i + ":  start " + dimstart[i] + ": len " + dimlen[i] + " current " + currentindex[i]
+                    + " bytetoindex " + bytetoindex[i] + " object " + objs[i] + " otype " + ss);
         }
     }
 }
diff --git a/java/src/hdf/hdf5lib/structs/H5A_info_t.java b/java/src/hdf/hdf5lib/structs/H5A_info_t.java
index 4bc1b0d..f2c10f0 100644
--- a/java/src/hdf/hdf5lib/structs/H5A_info_t.java
+++ b/java/src/hdf/hdf5lib/structs/H5A_info_t.java
@@ -20,10 +20,14 @@ import java.io.Serializable;
  */
 public class H5A_info_t implements Serializable{
     private static final long serialVersionUID = 2791443594041667613L;
-    public boolean corder_valid; // Indicate if creation order is valid
-    public long corder; // Creation order of attribute
-    public int cset; // Character set of attribute name
-    public long data_size; // Size of raw data
+    /** Indicate if creation order is valid */
+    public boolean corder_valid;
+    /** Creation order of attribute */
+    public long corder;
+    /** Character set of attribute name */
+    public int cset;
+    /** Size of raw data */
+    public long data_size;
 
     H5A_info_t(boolean corder_valid, long corder, int cset, long data_size) {
         this.corder_valid = corder_valid;