Nc4Iosp.java

/*
 * Copyright (c) 1998-2018 University Corporation for Atmospheric Research/Unidata
 * See LICENSE for license information.
 */

package ucar.nc2.jni.netcdf;

import static ucar.nc2.NetcdfFile.IOSP_MESSAGE_GET_NETCDF_FILE_FORMAT;
import static ucar.nc2.jni.netcdf.Nc4prototypes.*;
import com.sun.jna.Platform;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import ucar.ma2.*;
import ucar.nc2.*;
import ucar.nc2.constants.CDM;
import ucar.nc2.constants.DataFormatType;
import ucar.nc2.iosp.AbstractIOServiceProvider;
import ucar.nc2.iosp.IOServiceProviderWriter;
import ucar.nc2.iosp.IospHelper;
import ucar.nc2.iosp.NCheader;
import ucar.nc2.iosp.hdf4.HdfEos;
import ucar.nc2.iosp.hdf5.H5header;
import ucar.nc2.ffi.netcdf.NetcdfClibrary;
import ucar.nc2.iosp.netcdf4.Nc4;
import ucar.nc2.util.CancelTask;
import ucar.nc2.util.DebugFlags;
import ucar.nc2.util.EscapeStrings;
import ucar.nc2.write.Nc4Chunking;
import ucar.nc2.write.Nc4ChunkingDefault;
import ucar.unidata.io.RandomAccessFile;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.*;

/**
 * IOSP for reading netcdf files through JNA interface to netcdf C library
 *
 * @author caron
 * @see <a href="https://www.unidata.ucar.edu/software/netcdf/docs/netcdf-c.html" />
 * @see <a href="http://earthdata.nasa.gov/sites/default/files/field/document/ESDS-RFC-022v1.pdf" />
 * @see <a href=
 *      "https://www.unidata.ucar.edu/software/netcdf/docs/faq.html#How-can-I-convert-HDF5-files-into-netCDF-4-files" />
 *
 * @deprecated do not use, will be removed in ver 6.
 */
@Deprecated
public class Nc4Iosp extends AbstractIOServiceProvider implements IOServiceProviderWriter {
  private static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(Nc4Iosp.class);
  private static org.slf4j.Logger startupLog = org.slf4j.LoggerFactory.getLogger("serverStartup");

  public static final boolean DEBUG = false;

  public static int NC_TURN_OFF_LOGGING = -1;

  public static final String TRANSLATECONTROL = "ucar.translate";
  public static final String TRANSLATE_NONE = "none";
  public static final String TRANSLATE_NC4 = "nc4";

  private static Nc4prototypes nc4 = NetcdfClibrary.getForeignFunctionInterface();

  // TODO: These flags currently control debug messages that are printed to STDOUT. They ought to be logged to SLF4J.
  // We could use SLF4J markers to filter which debug-level messages are printed.
  // See http://stackoverflow.com/questions/12201112/can-i-add-custom-levels-to-slf4j
  private static final boolean debugCompound = false;
  private static final boolean debugCompoundAtt = false;
  private static final boolean debugDim = false;
  private static final boolean debugUserTypes = false;
  private static final boolean debugWrite = false;

  // if the default charset being used by java isn't UTF-8, then we will
  // need to transcode any string read into netCDf-Java via netCDF-C
  private static final boolean transcodeStrings = Charset.defaultCharset() != StandardCharsets.UTF_8;

  /**
   * set the path and name of the netcdf c library.
   * must be called before load() is called.
   *
   * @param jnaPath path to shared libraries
   * @param libName library name
   * @deprecated use NetcdfClibrary.setLibraryNameAndPath
   */
  @Deprecated
  public static void setLibraryAndPath(String jnaPath, String libName) {
    NetcdfClibrary.setLibraryNameAndPath(jnaPath, libName);
  }

  /**
   * Test if the netcdf C library is present and loaded.
   * 
   * @return true if present
   * @deprecated use NetcdfClibrary.isLibraryPresent
   */
  @Deprecated
  public static synchronized boolean isClibraryPresent() {
    return NetcdfClibrary.isLibraryPresent();
  }

  /** @deprecated use NetcdfClibrary.getNativeInterface */
  @Deprecated
  public static synchronized Nc4prototypes getCLibrary() {
    return nc4;
  }

  /**
   * Set the log level for loaded library.
   * Do nothing if set_log_level is not available.
   * 
   * @deprecated use NetcdfClibrary.setLogLevel
   */
  @Deprecated
  public static synchronized int setLogLevel(int level) {
    return NetcdfClibrary.setLogLevel(level);
  }

  private static boolean useHdfEos = true;

  public static void useHdfEos(boolean val) {
    useHdfEos = val;
  }

  public static void setDebugFlags(DebugFlags flags) {}

  //////////////////////////////////////////////////
  // Instance Variables

  private NetcdfFileWriter.Version version; // can use c library to create these different version files
  private boolean fill = true;
  private int ncid = -1; // file id
  private int format; // from nc_inq_format
  private boolean isClosed;

  private Map<Integer, UserType> userTypes = new HashMap<>(); // hash by typeid
  private Map<Group, Integer> groupHash = new HashMap<>(); // group -> nc4 grpid
  private Nc4Chunking chunker = new Nc4ChunkingDefault();
  private boolean isEos;

  private boolean markreserved;

  //////////////////////////////////////////////////
  // Constructor(s)

  public Nc4Iosp() {
    this(NetcdfFileWriter.Version.netcdf4); // ensure the version always has a value
  }

  public Nc4Iosp(NetcdfFileWriter.Version version) {
    this.version = version;
  }

  // called by reflection from NetcdfFileWriter
  public void setChunker(Nc4Chunking chunker) {
    if (chunker != null)
      this.chunker = chunker;
  }

  /**
   * Checks whether {@code raf} is a valid file NetCDF-4 file. Actually, it checks whether it is a valid HDF-5 file of
   * any type. Furthermore, it checks whether the NetCDF C library is available on the system. If both conditions are
   * satisfied, this method returns {@code true}; otherwise it returns {@code false}.
   *
   * @param raf a file on disk.
   * @return {@code true} if {@code raf} is a valid HDF-5 file and the NetCDF C library is available.
   * @throws IOException if an I/O error occurs.
   */
  @Override
  public boolean isValidFile(RandomAccessFile raf) throws IOException {
    int format = NCheader.checkFileType(raf);
    boolean valid = false;
    switch (format) {
      case NCheader.NC_FORMAT_NETCDF4:
      case NCheader.NC_FORMAT_64BIT_DATA:
        valid = true;
        break;
      default:
        break;// everything else is invalid
    }
    if (valid) {
      if (isClibraryPresent()) {
        return true;
      } else {
        log.debug("File is valid but the NetCDF-4 native library isn't installed: {}", raf.getLocation());
      }
    }

    return false;
  }

  // 2016-06-06 note: Once netcdf-c v4.4.1 is released, we should be able to return much better information from
  // getFileTypeDescription(), getFileTypeId(), and getFileTypeVersion() (inherited from superclass).
  // See https://goo.gl/pSP1Bq

  @Override
  public String getFileTypeDescription() {
    return "Netcdf/JNI: " + version;
  }

  @Override
  public String getFileTypeId() {
    if (isEos)
      return "HDF5-EOS";
    return version.isNetdf4format() ? DataFormatType.NETCDF4.getDescription() : DataFormatType.HDF5.getDescription();
  }

  @Override
  public String getFileTypeVersion() {
    // TODO this only works for files writtten by netcdf4 c library. what about plain hdf5?
    return ncfile.getRootGroup().findAttributeString(CDM.NCPROPERTIES, "N/A");
  }

  @Override
  public void close() throws IOException {
    if (isClosed)
      return;
    if (ncid < 0)
      return;
    int ret = nc4.nc_close(ncid);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    isClosed = true;
  }

  @Override
  public void open(RandomAccessFile raf, NetcdfFile ncfile, CancelTask cancelTask) throws IOException {
    super.open(raf, ncfile, cancelTask);
    _open(raf, ncfile, true);
  }

  @Override
  public void openForWriting(ucar.unidata.io.RandomAccessFile raf, ucar.nc2.NetcdfFile ncfile,
      ucar.nc2.util.CancelTask cancelTask) throws IOException {
    this.ncfile = ncfile;
    _open(raf, ncfile, false);
  }

  private void _open(RandomAccessFile raf, NetcdfFile ncfile, boolean readOnly) throws IOException {
    if (!isClibraryPresent()) {
      throw new UnsupportedOperationException("Couldn't load NetCDF C library (see log for details).");
    }

    if (raf != null)
      raf.close(); // not used

    // open
    // netcdf-c can't handle "file:" prefix. Must remove it.
    String location = NetcdfFiles.canonicalizeUriString(ncfile.getLocation());
    log.debug("open {}", location);

    IntByReference ncidp = new IntByReference();
    int ret = nc4.nc_open(location, readOnly ? NC_NOWRITE : NC_WRITE, ncidp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    isClosed = false;
    ncid = ncidp.getValue();

    // format
    IntByReference formatp = new IntByReference();
    ret = nc4.nc_inq_format(ncid, formatp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    format = formatp.getValue();
    log.debug("open {} id={} format={}", ncfile.getLocation(), ncid, format);

    // read root group
    makeGroup(new Group4(ncid, ncfile.getRootGroup(), null));

    // check if its an HDF5-EOS file
    Group eosInfo = ncfile.getRootGroup().findGroupLocal(HdfEos.HDF5_GROUP);
    if (eosInfo != null && useHdfEos) {
      isEos = HdfEos.amendFromODL(ncfile, eosInfo);
    }

    ncfile.finish();
  }

  private void makeGroup(Group4 g4) throws IOException {
    groupHash.put(g4.g, g4.grpid);

    makeDimensions(g4);
    makeUserTypes(g4.grpid, g4.g);

    // group attributes
    IntByReference ngattsp = new IntByReference();
    int ret = nc4.nc_inq_natts(g4.grpid, ngattsp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    List<Attribute> gatts = makeAttributes(g4.grpid, Nc4prototypes.NC_GLOBAL, ngattsp.getValue(), null);
    for (Attribute att : gatts) {
      ncfile.addAttribute(g4.g, att);
      log.debug(" add Global Attribute {}", att);
    }

    makeVariables(g4);

    if (format == Nc4prototypes.NC_FORMAT_NETCDF4) {
      // read subordinate groups
      IntByReference numgrps = new IntByReference();
      ret = nc4.nc_inq_grps(g4.grpid, numgrps, null);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));
      int[] group_ids = new int[numgrps.getValue()];
      ret = nc4.nc_inq_grps(g4.grpid, numgrps, group_ids);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));

      for (int group_id : group_ids) {
        byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
        ret = nc4.nc_inq_grpname(group_id, name);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        Group child = new Group(ncfile, g4.g, makeString(name));
        g4.g.addGroup(child);
        makeGroup(new Group4(group_id, child, g4));
      }
    }
  }

  private void makeDimensions(Group4 g4) throws IOException {
    // We need this in order to allocate the correct length for dimIdsInGroup.
    IntByReference numDimsInGoup_p = new IntByReference();
    int ret = nc4.nc_inq_ndims(g4.grpid, numDimsInGoup_p);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    IntByReference numDimidsInGroup_p = new IntByReference();
    int[] dimIdsInGroup = new int[numDimsInGoup_p.getValue()];
    ret = nc4.nc_inq_dimids(g4.grpid, numDimidsInGroup_p, dimIdsInGroup, 0);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    assert numDimsInGoup_p.getValue() == numDimidsInGroup_p.getValue() : String.format(
        "Number of dimensions in group (%s) differed from number of dimension IDs in group (%s).",
        numDimsInGoup_p.getValue(), numDimidsInGroup_p.getValue());

    // We need this in order to allocate the correct length for unlimitedDimIdsInGroup.
    IntByReference numUnlimitedDimsInGroup_p = new IntByReference();
    ret = nc4.nc_inq_unlimdims(g4.grpid, numUnlimitedDimsInGroup_p, null);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    int[] unlimitedDimIdsInGroup = new int[numUnlimitedDimsInGroup_p.getValue()];
    ret = nc4.nc_inq_unlimdims(g4.grpid, numUnlimitedDimsInGroup_p, unlimitedDimIdsInGroup);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    // Ensure array is sorted so that we can use binarySearch on it.
    Arrays.sort(unlimitedDimIdsInGroup);

    for (int dimId : dimIdsInGroup) {
      byte[] dimNameBytes = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      SizeTByReference dimLength_p = new SizeTByReference();
      ret = nc4.nc_inq_dim(g4.grpid, dimId, dimNameBytes, dimLength_p);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));

      String dimName = makeString(dimNameBytes);
      boolean isUnlimited = Arrays.binarySearch(unlimitedDimIdsInGroup, dimId) >= 0;

      Dimension dimension = new Dimension(dimName, dimLength_p.getValue().intValue(), true, isUnlimited, false);
      ncfile.addDimension(g4.g, dimension);
      log.debug("add Dimension {} ({})", dimension, dimId);
    }
  }

  private void updateDimensions(Group g) throws IOException {
    int grpid = groupHash.get(g);

    IntByReference nunlimdimsp = new IntByReference();
    int[] unlimdimids = new int[Nc4prototypes.NC_MAX_DIMS];
    int ret = nc4.nc_inq_unlimdims(grpid, nunlimdimsp, unlimdimids);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    int ndims = nunlimdimsp.getValue();
    for (int i = 0; i < ndims; i++) {
      byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      SizeTByReference lenp = new SizeTByReference();
      ret = nc4.nc_inq_dim(grpid, unlimdimids[i], name, lenp);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));
      String dname = makeString(name);

      Dimension d = g.findDimension(dname);
      if (d == null)
        throw new IllegalStateException("Cant find dimension " + dname);

      if (!d.isUnlimited())
        throw new IllegalStateException("dimension " + dname + " should be unlimited");

      // TODO udim.setLength : need UnlimitedDimension extends Dimension?
      int len = lenp.getValue().intValue();
      if (len != d.getLength()) {
        d.setLength(len);
        // must update all variables that use this dimension
        for (Variable var : g.getVariables()) {
          if (contains(var.getDimensions(), d)) {
            var.resetShape();
            var.invalidateCache();
          }
        }
      }
    }

    // recurse
    for (Group child : g.getGroups())
      updateDimensions(child);
  }

  // must check by name, not object equality
  private boolean contains(List<Dimension> dims, Dimension want) {
    for (Dimension have : dims) {
      if (have.getShortName().equals(want.getShortName()))
        return true;
    }
    return false;
  }

  /**
   * By default, JNA assumes strings coming into java from the C side are using
   * the system encoding. However, netCDF-C encodes using UTF-8. Because of this,
   * if we are on a platform where java is not using UTF-8 as the default encoding,
   * we will need to transcode the incoming strings fix the incorrect assumption
   * made by JNA.
   *
   * Note, we could set the system property jna.encode=UTF-8, but would impact the
   * behavior of other libraries that use JNA, and would not be very nice of us to
   * set globally (and often times isn't the right thing to set anyways, since the
   * default in C to use the system encoding).
   *
   * @param systemStrings String array encoded using the default charset
   * @return String array encoded using the UTF-8 charset
   */
  private String[] transcodeString(String[] systemStrings) {
    return Arrays.stream(systemStrings).map(systemString -> {
      byte[] byteArray = systemString.getBytes(Charset.defaultCharset());
      return new String(byteArray, StandardCharsets.UTF_8);
    }).toArray(String[]::new);
  }

  private String makeString(byte[] b) {
    // null terminates
    int count = 0;
    while (count < b.length) {
      if (b[count] == 0)
        break;
      count++; // dont include the terminating 0
    }

    // copy if its small
    if (count < b.length / 2) {
      byte[] bb = new byte[count];
      System.arraycopy(b, 0, bb, 0, count);
      b = bb;
    }
    return new String(b, 0, count, StandardCharsets.UTF_8); // all strings are considered to be UTF-8 unicode.
  }

  // follow what happens in the Java side
  private String makeAttString(byte[] b) {
    // null terminates
    int count = 0;
    while (count < b.length) {
      if (b[count] == 0)
        break;
      count++; // dont include the terminating 0
    }
    return new String(b, 0, count, StandardCharsets.UTF_8); // all strings are considered to be UTF-8 unicode.
  }

  private List<Attribute> makeAttributes(int grpid, int varid, int natts, Variable v) throws IOException {
    List<Attribute> result = new ArrayList<>(natts);

    for (int attnum = 0; attnum < natts; attnum++) {
      byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      int ret = nc4.nc_inq_attname(grpid, varid, attnum, name);
      if (ret != 0)
        throw new IOException(nc4.nc_strerror(ret) + " varid=" + varid + " attnum=" + attnum);
      String attname = makeString(name);
      IntByReference xtypep = new IntByReference();
      ret = nc4.nc_inq_atttype(grpid, varid, attname, xtypep);
      if (ret != 0)
        throw new IOException(nc4.nc_strerror(ret) + " varid=" + varid + "attnum=" + attnum);

      /*
       * xtypep : Pointer to location for returned attribute type,
       * one of the set of predefined netCDF external data types.
       * The type of this parameter, nc_type, is defined in the netCDF
       * header file. The valid netCDF external data types are
       * NC_BYTE, NC_CHAR, NC_SHORT, NC_INT, NC_FLOAT, and NC_DOUBLE.
       * If this parameter is given as '0' (a null pointer), no type
       * will be returned so no variable to hold the type needs to be declared.
       */
      int type = xtypep.getValue();
      SizeTByReference lenp = new SizeTByReference();
      ret = nc4.nc_inq_attlen(grpid, varid, attname, lenp);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));
      int len = lenp.getValue().intValue();

      // deal with empty attributes
      if (len == 0) {
        Attribute att;
        switch (type) {
          case Nc4prototypes.NC_BYTE:
            att = new Attribute(attname, DataType.BYTE);
            break;
          case Nc4prototypes.NC_UBYTE:
            att = new Attribute(attname, DataType.UBYTE);
            break;
          case Nc4prototypes.NC_CHAR:
            // From what I can tell, the way we should treat char attrs depends on
            // the netCDF format used (3 vs. 4)
            if ((format == NC_FORMAT_NETCDF4_CLASSIC) || (format == NC_FORMAT_NETCDF4)) {
              // if netcdf4, make null char attrs null string attrs
              att = new Attribute(attname, DataType.STRING);
            } else {
              // all others, treat null char attrs as empty string attrs
              att = new Attribute(attname, "");
            }
            break;
          case Nc4prototypes.NC_DOUBLE:
            att = new Attribute(attname, DataType.DOUBLE);
            break;
          case Nc4prototypes.NC_FLOAT:
            att = new Attribute(attname, DataType.FLOAT);
            break;
          case Nc4prototypes.NC_INT:
            att = new Attribute(attname, DataType.INT);
            break;
          case Nc4prototypes.NC_UINT:
            att = new Attribute(attname, DataType.UINT);
            break;
          case Nc4prototypes.NC_UINT64:
            att = new Attribute(attname, DataType.ULONG);
            break;
          case Nc4prototypes.NC_INT64:
            att = new Attribute(attname, DataType.LONG);
            break;
          case Nc4prototypes.NC_USHORT:
            att = new Attribute(attname, DataType.USHORT);
            break;
          case Nc4prototypes.NC_SHORT:
            att = new Attribute(attname, DataType.SHORT);
            break;
          case Nc4prototypes.NC_STRING:
            att = new Attribute(attname, DataType.STRING);
            break;
          default:
            log.warn("Unsupported attribute data type == " + type);
            continue;
        }
        result.add(att);
        continue; // avoid reading the values since there are none.
      }

      // read the att values
      Array values = null;

      switch (type) {

        case Nc4prototypes.NC_UBYTE:
          byte[] valbu = new byte[len];
          ret = nc4.nc_get_att_uchar(grpid, varid, attname, valbu);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.UBYTE, new int[] {len}, valbu);
          break;

        case Nc4prototypes.NC_BYTE:
          byte[] valb = new byte[len];
          ret = nc4.nc_get_att_schar(grpid, varid, attname, valb);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.BYTE, new int[] {len}, valb);
          break;

        case Nc4prototypes.NC_CHAR:
          byte[] text = new byte[len];
          ret = nc4.nc_get_att_text(grpid, varid, attname, text);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          Attribute att = new Attribute(attname, makeAttString(text));
          result.add(att);
          break;

        case Nc4prototypes.NC_DOUBLE:
          double[] vald = new double[len];
          ret = nc4.nc_get_att_double(grpid, varid, attname, vald);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.DOUBLE, new int[] {len}, vald);
          break;

        case Nc4prototypes.NC_FLOAT:
          float[] valf = new float[len];
          ret = nc4.nc_get_att_float(grpid, varid, attname, valf);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.FLOAT, new int[] {len}, valf);
          break;

        case Nc4prototypes.NC_UINT:
          int[] valiu = new int[len];
          ret = nc4.nc_get_att_uint(grpid, varid, attname, valiu);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.UINT, new int[] {len}, valiu);
          break;

        case Nc4prototypes.NC_INT:
          int[] vali = new int[len];
          ret = nc4.nc_get_att_int(grpid, varid, attname, vali);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.INT, new int[] {len}, vali);
          break;

        case Nc4prototypes.NC_UINT64:
          long[] vallu = new long[len];
          ret = nc4.nc_get_att_ulonglong(grpid, varid, attname, vallu);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.ULONG, new int[] {len}, vallu);
          break;

        case Nc4prototypes.NC_INT64:
          long[] vall = new long[len];
          ret = nc4.nc_get_att_longlong(grpid, varid, attname, vall);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.LONG, new int[] {len}, vall);
          break;

        case Nc4prototypes.NC_USHORT:
          short[] valsu = new short[len];
          ret = nc4.nc_get_att_ushort(grpid, varid, attname, valsu);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.USHORT, new int[] {len}, valsu);
          break;

        case Nc4prototypes.NC_SHORT:
          short[] vals = new short[len];
          ret = nc4.nc_get_att_short(grpid, varid, attname, vals);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          values = Array.factory(DataType.SHORT, new int[] {len}, vals);
          break;

        case Nc4prototypes.NC_STRING:
          String[] valss = new String[len];
          ret = nc4.nc_get_att_string(grpid, varid, attname, valss);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          if (transcodeStrings) {
            valss = transcodeString(valss);
          }
          values = Array.factory(DataType.STRING, new int[] {len}, valss);
          break;

        default:
          UserType userType = userTypes.get(type);
          if (userType == null) {
            log.warn("Unsupported attribute data type == " + type);
            continue;
          } else if (userType.typeClass == Nc4prototypes.NC_ENUM) {
            result.add(readEnumAttValues(grpid, varid, attname, len, userType));
            continue;
          } else if (userType.typeClass == Nc4prototypes.NC_OPAQUE) {
            result.add(readOpaqueAttValues(grpid, varid, attname, len, userType));
            continue;
          } else if (userType.typeClass == Nc4prototypes.NC_VLEN) {
            values = readVlenAttValues(grpid, varid, attname, len, userType);
          } else if (userType.typeClass == Nc4prototypes.NC_COMPOUND) {
            readCompoundAttValues(grpid, varid, attname, len, userType, result, v);
            continue;
          } else {
            log.warn("Unsupported attribute data type == " + userType);
            continue;
          }
      }
      if (values != null) {
        Attribute att = new Attribute(attname, values);
        result.add(att);
      }
    }
    return result;
  }

  private Array readVlenAttValues(int grpid, int varid, String attname, int len, UserType userType) throws IOException {
    Nc4prototypes.Vlen_t[] vlen = new Nc4prototypes.Vlen_t[len];
    int ret = nc4.nc_get_att(grpid, varid, attname, vlen); // vlen
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    int count = 0;
    for (int i = 0; i < len; i++)
      count += vlen[i].len;

    switch (userType.baseTypeid) {
      case Nc4prototypes.NC_INT:
        Array intArray = Array.factory(DataType.INT, new int[] {count});
        IndexIterator iter = intArray.getIndexIterator();
        for (int i = 0; i < len; i++) {
          // Coverity[FB.UWF_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD]
          int[] ba = vlen[i].p.getIntArray(0, vlen[i].len);
          for (int aBa : ba) {
            iter.setIntNext(aBa);
          }
        }
        return intArray;

      case Nc4prototypes.NC_FLOAT:
        Array fArray = Array.factory(DataType.FLOAT, new int[] {count});
        iter = fArray.getIndexIterator();
        for (int i = 0; i < len; i++) {
          // Coverity[FB.NP_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD]
          float[] ba = vlen[i].p.getFloatArray(0, vlen[i].len);
          for (float aBa : ba)
            iter.setFloatNext(aBa);
        }
        return fArray;
    }
    return null;
  }

  private Attribute readEnumAttValues(int grpid, int varid, String attname, int len, UserType userType)
      throws IOException {
    int ret;

    DataType dtype = convertDataType(userType.baseTypeid).dt;
    int elemSize = dtype.getSize();

    byte[] bbuff = new byte[len * elemSize];
    ret = nc4.nc_get_att(grpid, varid, attname, bbuff);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    ByteBuffer bb = ByteBuffer.wrap(bbuff);
    Array data = null;
    if (false) {
      /*
       * This is incorrect; CDM technically does not support
       * enum valued attributes (see Attribute.java).
       */
      data = convertByteBuffer(bb, userType.baseTypeid, new int[] {len});
    } else {
      /*
       * So, instead use the EnumTypedef to convert to econsts
       * and store as strings.
       */
      String[] econsts = new String[len];
      EnumTypedef en = userType.e;
      for (int i = 0; i < len; i++) {
        long lval = 0;
        switch (en.getBaseType()) {
          case ENUM1:
            lval = bb.get(i);
            break;
          case ENUM2:
            lval = bb.getShort(i);
            break;
          case ENUM4:
            lval = bb.getInt(i);
            break;
        }
        int ival = (int) lval;
        String name = en.lookupEnumString(ival);
        if (name == null) {
          name = "Unknown enum value=" + ival;
        }
        econsts[i] = name;
      }
      data = Array.factory(DataType.STRING, new int[] {len}, econsts);
    }
    Attribute a = new Attribute(attname, data);
    a.setEnumType(userType.e);
    return a;
  }

  private Array convertByteBuffer(ByteBuffer bb, int baseType, int[] shape) throws IOException {

    switch (baseType) {
      case Nc4prototypes.NC_BYTE:
        return Array.factory(DataType.BYTE, shape, bb.array());
      case Nc4prototypes.NC_UBYTE:
        return Array.factory(DataType.UBYTE, shape, bb.array());

      case Nc4prototypes.NC_SHORT:
        return Array.factory(DataType.SHORT, shape, bb.asShortBuffer().array());
      case Nc4prototypes.NC_USHORT:
        return Array.factory(DataType.USHORT, shape, bb.asShortBuffer().array());

      case Nc4prototypes.NC_INT:
        return Array.factory(DataType.INT, shape, bb.asIntBuffer().array());
      case Nc4prototypes.NC_UINT:
        return Array.factory(DataType.UINT, shape, bb.asIntBuffer().array());

      case Nc4prototypes.NC_INT64:
        return Array.factory(DataType.LONG, shape, bb.asLongBuffer().array());
      case Nc4prototypes.NC_UINT64:
        return Array.factory(DataType.ULONG, shape, bb.asLongBuffer().array());
    }
    throw new IllegalArgumentException("Illegal type=" + baseType);
  }

  private Attribute readOpaqueAttValues(int grpid, int varid, String attname, int len, UserType userType)
      throws IOException {
    int total = len * userType.size;
    byte[] bb = new byte[total];
    int ret = nc4.nc_get_att(grpid, varid, attname, bb);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    return new Attribute(attname, Array.factory(DataType.BYTE, new int[] {total}, bb));
  }

  private void readCompoundAttValues(int grpid, int varid, String attname, int len, UserType userType,
      List<Attribute> result, Variable v) throws IOException {

    int buffSize = len * userType.size;
    byte[] bb = new byte[buffSize];
    int ret = nc4.nc_get_att(grpid, varid, attname, bb);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    ByteBuffer bbuff = ByteBuffer.wrap(bb);
    decodeCompoundData(len, userType, bbuff);

    // if its a Structure, distribute to matching fields
    if (v instanceof Structure) {
      Structure s = (Structure) v;
      for (Field fld : userType.flds) {
        Variable mv = s.findVariable(fld.name);
        if (mv != null)
          mv.addAttribute(new Attribute(attname, fld.data));
        else
          result.add(new Attribute(attname + "." + fld.name, fld.data));
      }
    } else {
      for (Field fld : userType.flds)
        result.add(new Attribute(attname + "." + fld.name, fld.data));
    }
  }

  // LOOK: placing results in the fld of the userType - ok for production ??
  private void decodeCompoundData(int len, UserType userType, ByteBuffer bbuff) throws IOException {
    bbuff.order(ByteOrder.LITTLE_ENDIAN);

    for (Field fld : userType.flds) {
      ConvertedType ct = convertDataType(fld.fldtypeid);
      if (fld.fldtypeid == Nc4prototypes.NC_CHAR) {
        fld.data = Array.factory(DataType.STRING, new int[] {len}); // LOOK ??
      } else if (ct.isVlen) {
        // fld.data = Array.makeObjectArray(ct.dt, ct.dt.getPrimitiveClassType(), new int[]{len}, null);
        // fld.data = Array.makeVlenArray(ct.dt, ct.dt.getPrimitiveClassType(), new int[]{len}, null); LOOK BAD
      } else {
        fld.data = Array.factory(ct.dt, new int[] {len});
      }
    }

    for (int i = 0; i < len; i++) {
      int record_start = i * userType.size;

      for (Field fld : userType.flds) {
        int pos = record_start + fld.offset;

        switch (fld.fldtypeid) {
          case Nc4prototypes.NC_CHAR:
            // copy bytes out of buffer, make into a String object
            int blen = 1;
            if (fld.dims != null) {
              Section s = new Section(fld.dims);
              blen = (int) s.computeSize();
            }
            byte[] dst = new byte[blen];
            bbuff.get(dst, 0, blen);

            String cval = makeAttString(dst);
            fld.data.setObject(i, cval);
            if (debugCompoundAtt)
              System.out.println("result= " + cval);
            continue;

          case Nc4prototypes.NC_UBYTE:
          case Nc4prototypes.NC_BYTE:
            byte bval = bbuff.get(pos);
            if (debugCompoundAtt)
              System.out.println("bval= " + bval);
            fld.data.setByte(i, bval);
            continue;

          case Nc4prototypes.NC_USHORT:
          case Nc4prototypes.NC_SHORT:
            short sval = bbuff.getShort(pos);
            if (debugCompoundAtt)
              System.out.println("sval= " + sval);
            fld.data.setShort(i, sval);
            continue;

          case Nc4prototypes.NC_UINT:
          case Nc4prototypes.NC_INT:
            int ival = bbuff.getInt(pos);
            if (debugCompoundAtt)
              System.out.println("ival= " + ival);
            fld.data.setInt(i, ival);
            continue;

          case Nc4prototypes.NC_UINT64:
          case Nc4prototypes.NC_INT64:
            long lval = bbuff.getLong(pos);
            if (debugCompoundAtt)
              System.out.println("lval= " + lval);
            fld.data.setLong(i, lval);
            continue;

          case Nc4prototypes.NC_FLOAT:
            float fval = bbuff.getFloat(pos);
            if (debugCompoundAtt)
              System.out.println("fval= " + fval);
            fld.data.setFloat(i, fval);
            continue;

          case Nc4prototypes.NC_DOUBLE:
            double dval = bbuff.getDouble(pos);
            if (debugCompoundAtt)
              System.out.println("dval= " + dval);
            fld.data.setDouble(i, dval);
            continue;

          case Nc4prototypes.NC_STRING:
            lval = getNativeAddr(pos, bbuff);
            Pointer p = new Pointer(lval);
            String strval = p.getString(0, CDM.UTF8);
            fld.data.setObject(i, strval);
            if (debugCompoundAtt)
              System.out.println("result= " + strval);
            continue;

          default:
            UserType subUserType = userTypes.get(fld.fldtypeid);
            if (subUserType == null) {
              throw new IOException("Unknown compound user type == " + fld);
            } else if (subUserType.typeClass == Nc4prototypes.NC_ENUM) {
              // WTF ?
            } else if (subUserType.typeClass == Nc4prototypes.NC_VLEN) {
              decodeVlenField(fld, subUserType, pos, i, bbuff);
              break;
            } else if (subUserType.typeClass == Nc4prototypes.NC_OPAQUE) {
              // return readOpaque(grpid, varid, len, userType.size);
            } else if (subUserType.typeClass == Nc4prototypes.NC_COMPOUND) {
              // return readCompound(grpid, varid, len, userType);
            }

            log.warn("UNSUPPORTED compound fld.fldtypeid= " + fld.fldtypeid);
        } // switch on fld type
      } // loop over fields
    } // loop over len
  }

  /////////////////////////////////////////////////////////////////////////////

  private void makeVariables(Group4 g4) throws IOException {

    IntByReference nvarsp = new IntByReference();
    int ret = nc4.nc_inq_nvars(g4.grpid, nvarsp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    int nvars = nvarsp.getValue();
    log.debug("nvars= {}", nvars);

    int[] varids = new int[nvars];
    ret = nc4.nc_inq_varids(g4.grpid, nvarsp, varids);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    for (int i = 0; i < varids.length; i++) {
      int varno = varids[i];
      if (varno != i)
        log.error("makeVariables varno={} is not equal to {}", varno, i);

      byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      IntByReference xtypep = new IntByReference();
      IntByReference ndimsp = new IntByReference();
      int[] dimids = new int[Nc4prototypes.NC_MAX_DIMS];
      IntByReference nattsp = new IntByReference();

      ret = nc4.nc_inq_var(g4.grpid, varno, name, xtypep, ndimsp, dimids, nattsp);
      if (ret != 0)
        throw new IOException(nc4.nc_strerror(ret));

      // figure out the datatype
      int typeid = xtypep.getValue();
      // DataType dtype = convertDataType(typeid).dt;

      String vname = makeString(name);
      Vinfo vinfo = new Vinfo(g4, varno, typeid);

      // figure out the dimensions
      String dimList = makeDimList(g4.grpid, ndimsp.getValue(), dimids);
      UserType utype = userTypes.get(typeid);
      if (utype != null) {
        // Coverity[FB.URF_UNREAD_FIELD]
        vinfo.utype = utype;
        if (utype.typeClass == Nc4prototypes.NC_VLEN) // LOOK ??
          dimList = dimList + " *";
      }

      Variable v = makeVariable(g4.g, null, vname, typeid, dimList);
      /*
       * if(dtype != DataType.STRUCTURE) {
       * v = new Variable(ncfile, g, null, vname, dtype, dimList);
       * } else if(utype != null) {
       * Structure s = new Structure(ncfile, g, null, vname);
       * s.setDimensions(dimList);
       * v = s;
       * if(utype.flds == null)
       * utype.readFields();
       * for(Field f : utype.flds) {
       * s.addMemberVariable(f.makeMemberVariable(g, s));
       * }
       * } else {
       * throw new IllegalStateException("Dunno what to with " + dtype);
       * }
       */

      // create the Variable
      ncfile.addVariable(g4.g, v);
      v.setSPobject(vinfo);

      // if (isUnsigned(typeid))
      // v.addAttribute(new Attribute(CDM.UNSIGNED, "true"));

      // read Variable attributes
      List<Attribute> atts = makeAttributes(g4.grpid, varno, nattsp.getValue(), v);
      for (Attribute att : atts) {
        v.addAttribute(att);
      }

      log.debug("added Variable {}", v);
    }
  }

  private Variable makeVariable(Group g, Structure parent, String vname, int typeid, String dimList)
      throws IOException {
    ConvertedType cvttype = convertDataType(typeid);
    DataType dtype = cvttype.dt;
    UserType utype = userTypes.get(typeid);

    Variable v;
    if (dtype != DataType.STRUCTURE) {
      v = new Variable(ncfile, g, parent, vname, dtype, dimList);
    } else if (utype != null) {
      Structure s = new Structure(ncfile, g, parent, vname);
      s.setDimensions(dimList);
      v = s;
      if (utype.flds == null)
        utype.readFields();
      // Coverity[FORWARD_NULL]
      for (Field f : utype.flds) {
        s.addMemberVariable(f.makeMemberVariable(g, s));
      }
    } else {
      throw new IllegalStateException("Dunno what to with " + dtype);
    }

    if (dtype.isEnum()) {
      EnumTypedef enumTypedef = g.findEnumeration(utype.name, true);
      v.setEnumTypedef(enumTypedef);
    } else if (dtype == DataType.OPAQUE) {
      // TODO whats the problem with knowing the size?? Needed to read properly??
      if (this.markreserved) {
        // v.annotate(UCARTAGOPAQUE, utype.size);
      }
    }

    return v;
  }

  private String makeDimList(int grpid, int ndimsp, int[] dims) throws IOException {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < ndimsp; i++) {
      byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      int ret = nc4.nc_inq_dimname(grpid, dims[i], name);
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));
      String dname = makeString(name);
      sb.append(dname);
      sb.append(" ");
    }
    return sb.toString();
  }

  private boolean nc_inq_var(Formatter f, int grpid, int varno) throws IOException {
    byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
    IntByReference xtypep = new IntByReference();
    IntByReference ndimsp = new IntByReference();
    int[] dimids = new int[Nc4prototypes.NC_MAX_DIMS];
    IntByReference nattsp = new IntByReference();

    int ret = nc4.nc_inq_var(grpid, varno, name, xtypep, ndimsp, dimids, nattsp);
    if (ret != 0)
      return false;

    String vname = makeString(name);
    int typeid = xtypep.getValue();
    ConvertedType cvt = convertDataType(typeid);

    for (int i = 0; i < ndimsp.getValue(); i++) {
      f.format("%d ", dimids[i]);
    }

    String dimList = makeDimList(grpid, ndimsp.getValue(), dimids);

    f.format(") dims=(%s)%n", dimList);
    return true;
  }

  private String nc_inq_var_name(int grpid, int varno) throws IOException {
    byte[] name = new byte[Nc4prototypes.NC_MAX_NAME + 1];
    IntByReference xtypep = new IntByReference();
    IntByReference ndimsp = new IntByReference();
    IntByReference nattsp = new IntByReference();

    int ret = nc4.nc_inq_var(grpid, varno, name, xtypep, ndimsp, null, nattsp);
    if (ret != 0)
      throw new IOException("nc_inq_var faild: code=" + ret);
    return makeString(name);
  }
  //////////////////////////////////////////////////////////////////////////

  static class Vinfo {
    final Group4 g4;
    int varid, typeid;
    UserType utype; // may be null

    Vinfo(Group4 g4, int varid, int typeid) {
      this.g4 = g4;
      this.varid = varid;
      this.typeid = typeid;
    }
  }

  static class Group4 {
    final int grpid;
    final Group g;
    final Group4 parent;
    Map<Dimension, Integer> dimHash;

    Group4(int grpid, Group g, Group4 parent) {
      this.grpid = grpid;
      this.g = g;
      this.parent = parent;
    }
  }

  // Cannot be static because it references non-static parent class memebers
  // Coverity[FB.SIC_INNER_SHOULD_BE_STATIC]
  private class UserType {
    int grpid;
    int typeid;
    String name;
    int size; // the size of the user defined type
    int baseTypeid; // the base typeid for vlen and enum types
    long nfields; // the number of fields for enum and compound types
    int typeClass; // the class of the user defined type: NC_VLEN, NC_OPAQUE, NC_ENUM, or NC_COMPOUND.

    EnumTypedef e;
    List<Field> flds;

    UserType(int grpid, int typeid, String name, long size, int baseTypeid, long nfields, int typeClass)
        throws IOException {
      this.grpid = grpid;
      this.typeid = typeid;
      this.name = name;
      this.size = (int) size;
      this.baseTypeid = baseTypeid;
      this.nfields = nfields;
      this.typeClass = typeClass;
      if (debugUserTypes)
        System.out.printf("%s%n", this);

      if (typeClass == Nc4prototypes.NC_COMPOUND)
        readFields();
    }

    // Allow size override for e.g. opaque
    public UserType setSize(int size) {
      this.size = size;
      return this;
    }

    DataType getEnumBaseType() {
      // set the enum's basetype
      if (baseTypeid > 0 && baseTypeid <= NC_MAX_ATOMIC_TYPE) {
        DataType cdmtype;
        switch (baseTypeid) {
          case NC_CHAR:
          case NC_UBYTE:
          case NC_BYTE:
            cdmtype = DataType.ENUM1;
            break;
          case NC_USHORT:
          case NC_SHORT:
            cdmtype = DataType.ENUM2;
            break;
          case NC_UINT:
          case NC_INT:
          default:
            cdmtype = DataType.ENUM4;
            break;
        }
        return cdmtype;
      }
      return null;
    }

    void addField(Field fld) {
      if (flds == null)
        flds = new ArrayList<>(10);
      flds.add(fld);
    }

    void setFields(List<Field> flds) {
      this.flds = flds;
    }

    public String toString2() {
      return "name='" + name + "' id=" + getDataTypeName(typeid) + " userType=" + getDataTypeName(typeClass)
          + " baseType=" + getDataTypeName(baseTypeid);
    }

    @Override
    public String toString() {
      return "UserType" + "{grpid=" + grpid + ", typeid=" + typeid + ", name='" + name + '\'' + ", size=" + size
          + ", baseTypeid=" + baseTypeid + ", nfields=" + nfields + ", typeClass=" + typeClass + ", e=" + e + '}';
    }

    void readFields() throws IOException {
      for (int fldidx = 0; fldidx < nfields; fldidx++) {
        byte[] fldname = new byte[Nc4prototypes.NC_MAX_NAME + 1];
        IntByReference field_typeidp = new IntByReference();
        IntByReference ndimsp = new IntByReference();
        SizeTByReference offsetp = new SizeTByReference();

        int[] dims = new int[Nc4prototypes.NC_MAX_DIMS];
        int ret = nc4.nc_inq_compound_field(grpid, typeid, fldidx, fldname, offsetp, field_typeidp, ndimsp, dims);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));

        Field fld = new Field(grpid, typeid, fldidx, makeString(fldname), offsetp.getValue().intValue(),
            field_typeidp.getValue(), ndimsp.getValue(), dims);

        addField(fld);
        if (debugUserTypes)
          System.out.printf(" %s add field= %s%n", name, fld);
      }
    }
  }

  // encapsolate the fields in a compound type
  // Cannot be static because it references non-static parent class members
  // Coverity[FB.SIC_INNER_SHOULD_BE_STATIC]
  private class Field {
    int grpid;
    int typeid; // containing structure
    int fldidx;
    String name;
    int offset;
    int fldtypeid;
    int ndims;
    int[] dims;

    ConvertedType ctype;
    // int total_size;
    Array data;

    // grpid, varid, fldidx, fldname, offsetp, field_typeidp, ndimsp, dim_sizesp
    Field(int grpid, int typeid, int fldidx, String name, int offset, int fldtypeid, int ndims, int[] dimz) {
      this.grpid = grpid;
      this.typeid = typeid;
      this.fldidx = fldidx;
      this.name = name;
      this.offset = offset;
      this.fldtypeid = fldtypeid;
      // Reduce the stored dimensions to match the actual rank
      // because some code (i.e. Section) is using this.dims.length
      // to compute the rank.
      this.ndims = ndims;
      this.dims = new int[ndims];
      System.arraycopy(dimz, 0, this.dims, 0, ndims);

      ctype = convertDataType(fldtypeid);
      // Section s = new Section(this.dims);
      // total_size = (int) s.computeSize() * ctype.dt.getSize();

      if (isVlen(fldtypeid)) {
        int[] edims = new int[ndims + 1];
        if (ndims > 0)
          System.arraycopy(dimz, 0, edims, 0, ndims);
        edims[ndims] = -1;
        this.dims = edims;
        this.ndims++;
      }
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }
      Field field = (Field) o;
      return grpid == field.grpid && typeid == field.typeid && fldidx == field.fldidx && offset == field.offset
          && fldtypeid == field.fldtypeid && ndims == field.ndims && Objects.equals(name, field.name)
          && Arrays.equals(dims, field.dims);
    }

    @Override
    public int hashCode() {
      return Objects.hash(grpid, typeid, fldidx, name, offset, fldtypeid, ndims, dims);
    }

    public String toString2() {
      return "name='" + name + " fldtypeid=" + getDataTypeName(fldtypeid) + " ndims=" + ndims + " offset=" + offset;
    }

    @Override
    public String toString() {
      StringBuilder sb = new StringBuilder();
      sb.append("Field");
      sb.append("{grpid=").append(grpid);
      sb.append(", typeid=").append(typeid);
      sb.append(", fldidx=").append(fldidx);
      sb.append(", name='").append(name).append('\'');
      sb.append(", offset=").append(offset);
      sb.append(", fldtypeid=").append(fldtypeid);
      sb.append(", ndims=").append(ndims);
      sb.append(", dims=").append(dims == null ? "null" : "");
      for (int i = 0; dims != null && i < dims.length; ++i)
        sb.append(i == 0 ? "" : ", ").append(dims[i]);
      sb.append(", dtype=").append(ctype.dt);
      if (ctype.isVlen)
        sb.append("(vlen)");
      sb.append('}');
      return sb.toString();
    }

    /*
     * Variable makeMemberVariable(Group g, Structure parent)
     * {
     * Variable v = new Variable(ncfile, g, parent, name);
     * v.setDataType(convertDataType(fldtypeid).dt);
     * if(isUnsigned(fldtypeid))
     * v.addAttribute(new Attribute(CDM.UNSIGNED, "true"));
     * 
     * if(ctype.isVlen) {
     * v.setDimensions("*");
     * } else {
     * try {
     * v.setDimensionsAnonymous(dims);
     * } catch (InvalidRangeException e) {
     * e.printStackTrace();
     * }
     * }
     * return v;
     * }
     */

    Variable makeMemberVariable(Group g, Structure parent) throws IOException {
      Variable v = makeVariable(g, parent, name, fldtypeid, "");

      // if(ctype.isVlen) {
      // v.setDimensions("*");
      // } else
      {
        try {
          v.setDimensionsAnonymous(dims); // LOOK no shared dimensions ?
        } catch (InvalidRangeException e) {
          e.printStackTrace();
        }
      }
      return v;
    }
  }

  private void makeUserTypes(int grpid, Group g) throws IOException {
    // find user types in this group
    IntByReference ntypesp = new IntByReference();
    int ret = nc4.nc_inq_typeids(grpid, ntypesp, null);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    int ntypes = ntypesp.getValue();
    if (ntypes == 0)
      return;
    int[] xtypes = new int[ntypes];
    ret = nc4.nc_inq_typeids(grpid, ntypesp, xtypes);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    // for each defined "user type", get information, store in Map
    for (int typeid : xtypes) {
      byte[] nameb = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      SizeTByReference sizep = new SizeTByReference();
      IntByReference baseType = new IntByReference();
      SizeTByReference nfieldsp = new SizeTByReference();
      IntByReference classp = new IntByReference();

      /*
       * ncid The ncid for the group containing the user defined type.
       * xtype The typeid for this type, as returned by nc_def_compound, nc_def_opaque, nc_def_enum, nc_def_vlen, or
       * nc_inq_var.
       * name If non-NULL, the name of the user defined type will be copied here. It will be NC_MAX_NAME bytes or less.
       * sizep If non-NULL, the (in-memory) size of the type in bytes will be copied here. VLEN type size is the size of
       * nc_vlen_t.
       * String size is returned as the size of a character pointer. The size may be used to malloc space for the data,
       * no matter what the type.
       * nfieldsp If non-NULL, the number of fields will be copied here for enum and compound types.
       * classp Return the class of the user defined type, NC_VLEN, NC_OPAQUE, NC_ENUM, or NC_COMPOUND.
       */
      ret = nc4.nc_inq_user_type(grpid, typeid, nameb, sizep, baseType, nfieldsp, classp); // size_t
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));

      String name = makeString(nameb);
      int utype = classp.getValue();
      log.debug("user type id={} name={} size={} baseType={} nfields={} class={}", typeid, name,
          sizep.getValue().longValue(), baseType.getValue(), nfieldsp.getValue().longValue(), utype);

      UserType ut = new UserType(grpid, typeid, name, sizep.getValue().longValue(), baseType.getValue(),
          nfieldsp.getValue().longValue(), utype);
      userTypes.put(typeid, ut);

      if (utype == Nc4prototypes.NC_ENUM) {
        Map<Integer, String> map = makeEnum(grpid, typeid);
        ut.e = new EnumTypedef(name, map, ut.getEnumBaseType());
        g.addEnumeration(ut.e);

      } else if (utype == Nc4prototypes.NC_OPAQUE) {
        byte[] nameo = new byte[Nc4prototypes.NC_MAX_NAME + 1];
        SizeTByReference sizep2 = new SizeTByReference();
        ret = nc4.nc_inq_opaque(grpid, typeid, nameo, sizep2);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        ut.setSize(sizep2.getValue().intValue());
        // doesnt seem to be any new info
        // String nameos = makeString(nameo);
      }
    }
  }


  public static void dumpbytes(byte[] bytes, int start, int len, String tag) {
    System.err.println("++++++++++ " + tag + " ++++++++++ ");
    int stop = start + len;
    try {
      for (int i = 0; i < stop; i++) {
        byte b = bytes[i];
        int ib = (int) b;
        int ub = (ib & 0xFF);
        char c = (char) ub;
        String s = Character.toString(c);
        if (c == '\r')
          s = "\\r";
        else if (c == '\n')
          s = "\\n";
        else if (c < ' ')
          s = "?";
        System.err.printf("[%03d] %02x %03d %4d '%s'", i, ub, ub, ib, s);
        System.err.println();
        System.err.flush();
      }

    } catch (Exception e) {
      System.err.println("failure:" + e);
    } finally {
      System.err.println("++++++++++ " + tag + " ++++++++++ ");
      System.err.flush();
    }
  }

  private Map<Integer, String> makeEnum(int grpid, int xtype) throws IOException {
    byte[] nameb = new byte[Nc4prototypes.NC_MAX_NAME + 1];
    IntByReference baseType = new IntByReference();
    SizeTByReference baseSize = new SizeTByReference();
    SizeTByReference numMembers = new SizeTByReference();

    int ret = nc4.nc_inq_enum(grpid, xtype, nameb, baseType, baseSize, numMembers);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    int nmembers = numMembers.getValue().intValue();

    Map<Integer, String> map = new HashMap<>(2 * nmembers);

    for (int i = 0; i < nmembers; i++) {
      byte[] mnameb = new byte[Nc4prototypes.NC_MAX_NAME + 1];
      IntByReference value = new IntByReference();
      ret = nc4.nc_inq_enum_member(grpid, xtype, i, mnameb, value); // void *
      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));

      String mname = makeString(mnameb);
      map.put(value.getValue(), mname);
    }
    return map;
  }

  /////////////////////////////////////////////////////////////////////////////////

  @Override
  public Array readData(Variable v2, Section section) throws IOException, InvalidRangeException {
    Vinfo vinfo = (Vinfo) v2.getSPobject();
    int vlen = (int) v2.getSize();
    int len = (int) section.computeSize();
    if (vlen == len) // entire array
      return readDataAll(vinfo.g4.grpid, vinfo.varid, vinfo.typeid, v2.getShapeAsSection());

    // if(!section.isStrided()) // optimisation for unstrided section
    // return readUnstrided(vinfo.grpid, vinfo.varid, vinfo.typeid, section);

    return readDataSection(vinfo.g4.grpid, vinfo.varid, vinfo.typeid, section);
  }

  Array readDataSection(int grpid, int varid, int typeid, Section section) throws IOException, InvalidRangeException {
    // general sectioning with strides
    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    SizeT[] stride = convertSizeT(section.getStride());

    boolean isUnsigned = isUnsigned(typeid);
    int len = (int) section.computeSize();
    Array values;

    switch (typeid) {
      // int nc_get_vars_schar(int ncid, int varid, long[] startp, long[] countp, int[] stridep, byte[] ip);

      case Nc4prototypes.NC_BYTE:
      case Nc4prototypes.NC_UBYTE:
        byte[] valb = new byte[len];
        int ret;
        ret = isUnsigned ? nc4.nc_get_vars_uchar(grpid, varid, origin, shape, stride, valb)
            : nc4.nc_get_vars_schar(grpid, varid, origin, shape, stride, valb);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.BYTE, section.getShape(), valb);
        break;

      case Nc4prototypes.NC_CHAR:
        byte[] valc = new byte[len];
        ret = nc4.nc_get_vars_text(grpid, varid, origin, shape, stride, valc);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.CHAR, section.getShape(), IospHelper.convertByteToChar(valc));
        break;

      case Nc4prototypes.NC_DOUBLE:
        double[] vald = new double[len];
        ret = nc4.nc_get_vars_double(grpid, varid, origin, shape, stride, vald);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.DOUBLE, section.getShape(), vald);
        break;

      case Nc4prototypes.NC_FLOAT:
        float[] valf = new float[len];
        ret = nc4.nc_get_vars_float(grpid, varid, origin, shape, stride, valf);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.FLOAT, section.getShape(), valf);
        break;

      case Nc4prototypes.NC_INT:
      case Nc4prototypes.NC_UINT:
        int[] vali = new int[len];

        ret = isUnsigned ? nc4.nc_get_vars_uint(grpid, varid, origin, shape, stride, vali)
            : nc4.nc_get_vars_int(grpid, varid, origin, shape, stride, vali);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.INT, section.getShape(), vali);
        break;

      case Nc4prototypes.NC_INT64:
      case Nc4prototypes.NC_UINT64:
        long[] vall = new long[len];
        ret = isUnsigned ? nc4.nc_get_vars_ulonglong(grpid, varid, origin, shape, stride, vall)
            : nc4.nc_get_vars_longlong(grpid, varid, origin, shape, stride, vall);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.LONG, section.getShape(), vall);
        break;

      case Nc4prototypes.NC_SHORT:
      case Nc4prototypes.NC_USHORT:
        short[] vals = new short[len];
        ret = isUnsigned ? nc4.nc_get_vars_ushort(grpid, varid, origin, shape, stride, vals)
            : nc4.nc_get_vars_short(grpid, varid, origin, shape, stride, vals);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        values = Array.factory(DataType.SHORT, section.getShape(), vals);
        break;

      case Nc4prototypes.NC_STRING:
        String[] valss = new String[len];
        ret = nc4.nc_get_vars_string(grpid, varid, origin, shape, stride, valss);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        if (transcodeStrings) {
          valss = transcodeString(valss);
        }
        return Array.factory(DataType.STRING, section.getShape(), valss);

      default:
        UserType userType = userTypes.get(typeid);
        if (userType == null) {
          throw new IOException("Unknown userType == " + typeid);
        } else if (userType.typeClass == Nc4prototypes.NC_ENUM) {
          return readDataSection(grpid, varid, userType.baseTypeid, section);
        } else if (userType.typeClass == Nc4prototypes.NC_VLEN) { // cannot subset
          return readVlen(grpid, varid, userType, section);
        } else if (userType.typeClass == Nc4prototypes.NC_OPAQUE) {
          return readOpaque(grpid, varid, section, userType.size);
        } else if (userType.typeClass == Nc4prototypes.NC_COMPOUND) {
          return readCompound(grpid, varid, section, userType);
        }
        throw new IOException("Unsupported userType = " + typeid + " userType= " + userType);
    }
    return values;
  }

  // read entire array
  private Array readDataAll(int grpid, int varid, int typeid, Section section)
      throws IOException, InvalidRangeException {
    int ret;
    int len = (int) section.computeSize();
    int[] shape = section.getShape();

    switch (typeid) {

      case Nc4prototypes.NC_UBYTE:
        byte[] valbu = new byte[len];
        ret = nc4.nc_get_var_ubyte(grpid, varid, valbu);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.UBYTE, shape, valbu);

      case Nc4prototypes.NC_BYTE:
        byte[] valb = new byte[len];
        ret = nc4.nc_get_var_schar(grpid, varid, valb);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.BYTE, shape, valb);

      case Nc4prototypes.NC_CHAR:
        byte[] valc = new byte[len];
        ret = nc4.nc_get_var_text(grpid, varid, valc);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        char[] cvals = IospHelper.convertByteToChar(valc);
        return Array.factory(DataType.CHAR, shape, cvals);

      case Nc4prototypes.NC_DOUBLE:
        double[] vald = new double[len];
        ret = nc4.nc_get_var_double(grpid, varid, vald);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.DOUBLE, shape, vald);

      case Nc4prototypes.NC_FLOAT:
        float[] valf = new float[len];
        ret = nc4.nc_get_var_float(grpid, varid, valf);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.FLOAT, shape, valf);

      case Nc4prototypes.NC_INT:
        int[] vali = new int[len];
        ret = nc4.nc_get_var_int(grpid, varid, vali);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.INT, shape, vali);

      case Nc4prototypes.NC_INT64:
        long[] vall = new long[len];
        ret = nc4.nc_get_var_longlong(grpid, varid, vall);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.LONG, shape, vall);

      case Nc4prototypes.NC_UINT64:
        long[] vallu = new long[len];
        ret = nc4.nc_get_var_ulonglong(grpid, varid, vallu);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.ULONG, shape, vallu);

      case Nc4prototypes.NC_SHORT:
        short[] vals = new short[len];
        ret = nc4.nc_get_var_short(grpid, varid, vals);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.SHORT, shape, vals);

      case Nc4prototypes.NC_USHORT:
        short[] valsu = new short[len];
        ret = nc4.nc_get_var_ushort(grpid, varid, valsu);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.USHORT, shape, valsu);

      case Nc4prototypes.NC_UINT:
        int[] valiu = new int[len];
        ret = nc4.nc_get_var_uint(grpid, varid, valiu);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        return Array.factory(DataType.UINT, shape, valiu);

      case Nc4prototypes.NC_STRING:
        String[] valss = new String[len];
        ret = nc4.nc_get_var_string(grpid, varid, valss);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        if (transcodeStrings) {
          valss = transcodeString(valss);
        }
        return Array.factory(DataType.STRING, shape, valss);

      default:
        UserType userType = userTypes.get(typeid);
        if (userType == null) {
          throw new IOException("Unknown userType == " + typeid);
        } else if (userType.typeClass == Nc4prototypes.NC_ENUM) {
          int buffSize = len * userType.size;
          byte[] bbuff = new byte[buffSize];
          // read in the data
          ret = nc4.nc_get_var(grpid, varid, bbuff);
          if (ret != 0)
            throw new IOException(ret + ": " + nc4.nc_strerror(ret));
          ByteBuffer bb = ByteBuffer.wrap(bbuff);
          bb.order(ByteOrder.nativeOrder()); // c library returns in native order i hope

          switch (userType.baseTypeid) {
            case Nc4prototypes.NC_BYTE:
              return Array.factory(DataType.BYTE, shape, bb);
            case Nc4prototypes.NC_UBYTE:
              return Array.factory(DataType.UBYTE, shape, bb);
            case Nc4prototypes.NC_SHORT:
              return Array.factory(DataType.SHORT, shape, bb);
            case Nc4prototypes.NC_USHORT:
              return Array.factory(DataType.USHORT, shape, bb);
            case Nc4prototypes.NC_INT:
              return Array.factory(DataType.INT, shape, bb);
            case Nc4prototypes.NC_UINT:
              return Array.factory(DataType.UINT, shape, bb);
          }
          throw new IOException("unknown type " + userType.baseTypeid);
        } else if (userType.typeClass == Nc4prototypes.NC_VLEN) {
          return readVlen(grpid, varid, userType, section);
        } else if (userType.typeClass == Nc4prototypes.NC_OPAQUE) {
          return readOpaque(grpid, varid, section, userType.size);
        } else if (userType.typeClass == Nc4prototypes.NC_COMPOUND) {
          return readCompound(grpid, varid, section, userType);
        }
        throw new IOException("Unsupported userType = " + typeid + " userType= " + userType);
    }
  }

  private Array readCompound(int grpid, int varid, Section section, UserType userType) throws IOException {
    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    SizeT[] stride = convertSizeT(section.getStride());
    int len = (int) section.computeSize();

    int buffSize = len * userType.size;
    byte[] bbuff = new byte[buffSize];

    // read in the data
    int ret;
    ret = nc4.nc_get_vars(grpid, varid, origin, shape, stride, bbuff);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    ByteBuffer bb = ByteBuffer.wrap(bbuff);
    bb.order(ByteOrder.nativeOrder()); // c library returns in native order i hope

    /*
     * This does not seem right since the user type does not
     * normally appear in the CDM representation.
     * dmh: observation is correct, var name should be used instead of
     * usertype.name, at least for now and to be consistent with H5Iosp.
     * This is not easy, however, because we have to re-read the variable's name.
     * and ideally this would be in the Vinfo, but we have no easy way to get that either.
     */
    String vname = nc_inq_var_name(grpid, varid);
    StructureMembers sm = createStructureMembers(userType, vname);
    ArrayStructureBB asbb = new ArrayStructureBB(sm, section.getShape(), bb, 0);

    // find and convert String and vlen fields, put on asbb heap
    int destPos = 0;
    for (int i = 0; i < len; i++) { // loop over each structure
      convertHeap(asbb, destPos, sm);
      destPos += userType.size;
    }
    return asbb;
  }

  private StructureMembers createStructureMembers(UserType userType, String varname) {
    // Incorrect: StructureMembers sm = new StructureMembers(userType.name);
    StructureMembers.Builder sm = StructureMembers.builder().setName(varname);
    for (Field fld : userType.flds) {
      StructureMembers.MemberBuilder mb = sm.addMember(fld.name, null, null, fld.ctype.dt, fld.dims);
      mb.setDataParam(fld.offset);
      /*
       * This should already have been taken care of
       * if(fld.ctype.isVlen) {m.setShape(new int[]{-1}); }
       */

      if (fld.ctype.dt == DataType.STRUCTURE) {
        UserType nested_utype = userTypes.get(fld.fldtypeid);
        String partfqn = EscapeStrings.backslashEscapeCDMString(varname, ".") + "."
            + EscapeStrings.backslashEscapeCDMString(fld.name, ".");
        StructureMembers nested_sm = createStructureMembers(nested_utype, partfqn);
        mb.setStructureMembers(nested_sm);
      }
    }
    sm.setStructureSize(userType.size);
    return sm.build();
  }

  // LOOK: handling nested ??
  private void convertHeap(ArrayStructureBB asbb, int pos, StructureMembers sm) throws IOException {
    ByteBuffer bb = asbb.getByteBuffer();
    for (StructureMembers.Member m : sm.getMembers()) {
      if (m.getDataType() == DataType.STRING) {
        int size = m.getSize();
        int destPos = pos + m.getDataParam();
        String[] result = new String[size];
        for (int i = 0; i < size; i++) {
          long addr = getNativeAddr(pos, bb);
          Pointer p = new Pointer(addr);
          result[i] = p.getString(0, CDM.UTF8);
        }
        int index = asbb.addObjectToHeap(result);
        bb.putInt(destPos, index); // overwrite with the index into the StringHeap

      } else if (m.isVariableLength()) {
        // We need to do like readVLEN, but store the resulting array
        // in the asbb heap (a bit of a hack).
        // we assume that pos "points" to the beginning of this structure instance
        // and so pos + m.getDataParam() "points" to field m in this structure instance.
        int nc_vlen_t_size = (new Nc4prototypes.Vlen_t()).size();
        int startPos = pos + m.getDataParam();
        // Compute rank and size upto the first (and ideally last) VLEN
        int[] fieldshape = m.getShape();
        int prefixrank = 0;
        int size = 1;
        for (; prefixrank < fieldshape.length; prefixrank++) {
          if (fieldshape[prefixrank] < 0)
            break;
          size *= fieldshape[prefixrank];
        }
        assert size == m.getSize() : "Internal error: field size mismatch";
        Array[] fieldarray = new Array[size]; // hold all the nc_vlen_t instance data
        // destPos will point to each nc_vlen_t instance in turn
        // assuming we have 'size' such instances in a row.
        int destPos = startPos;
        for (int i = 0; i < size; i++) {
          // vlenarray extracts the i'th nc_vlen_t contents (struct not supported).
          Array vlenArray = decodeVlen(m.getDataType(), destPos, bb);
          fieldarray[i] = vlenArray;
          destPos += nc_vlen_t_size;
        }
        Array result;
        if (prefixrank == 0) // if scalar, return just the singleton vlen array
          result = fieldarray[0];

        else {
          int[] newshape = new int[prefixrank];
          System.arraycopy(fieldshape, 0, newshape, 0, prefixrank);
          // result = Array.makeObjectArray(m.getDataType(), fieldarray[0].getClass(), newshape, fieldarray);
          result = Array.makeVlenArray(newshape, fieldarray);
        }

        /*
         * else if (prefixrank == 1)
         * result = Array.makeObjectArray(m.getDataType(), fieldarray[0].getClass(), new int[]{size}, fieldarray);
         * 
         * else {
         * // Otherwise create and fill in an n-dimensional Array Of Arrays
         * int[] newshape = new int[prefixrank];
         * System.arraycopy(fieldshape, 0, newshape, 0, prefixrank);
         * Array ndimarray = Array.makeObjectArray(m.getDataType(), Array.class, newshape, null);
         * // Transfer the elements of data into the n-dim arrays
         * IndexIterator iter = ndimarray.getIndexIterator();
         * for (int i = 0; iter.hasNext(); i++) {
         * iter.setObjectNext(fieldarray[i]);
         * }
         * result = ndimarray;
         * }
         */
        // Store vlen result in the heap
        int index = asbb.addObjectToHeap(result);
        bb.order(ByteOrder.nativeOrder()); // the string index is always written in "native order"
        bb.putInt(startPos, index); // overwrite with the index into the StringHeap
      }
    }
  }

  private void decodeVlenField(Field fld, UserType userType, int pos, int idx, ByteBuffer bbuff) throws IOException {
    ConvertedType cvt = convertDataType(userType.baseTypeid);
    Array array = decodeVlen(cvt.dt, pos, bbuff);
    fld.data.setObject(idx, array);
  }

  private Array decodeVlen(DataType dt, int pos, ByteBuffer bbuff) throws IOException {
    Array array;
    int n = (int) bbuff.getLong(pos); // Note that this does not increment the buffer position
    long addr = getNativeAddr(pos + com.sun.jna.Native.POINTER_SIZE, bbuff);
    Pointer p = new Pointer(addr);
    Object data;
    switch (dt) {
      case BOOLEAN: /* byte[] */
      case ENUM1:
      case BYTE:
        data = p.getByteArray(0, n);
        break;
      case ENUM2:
      case SHORT: /* short[] */
        data = p.getShortArray(0, n);
        break;
      case ENUM4:
      case INT: /* int[] */
        data = p.getIntArray(0, n);
        break;
      case LONG: /* long[] */
        data = p.getLongArray(0, n);
        break;
      case FLOAT: /* float[] */
        data = p.getFloatArray(0, n);
        break;
      case DOUBLE: /* double[] */
        data = p.getDoubleArray(0, n);
        break;
      case CHAR: /* char[] */
        data = p.getCharArray(0, n);
        break;
      case STRING: /* String[] */
        // For now we need to use p.getString()
        // because p.getStringArray(int,int) does not exist
        // in jna version 3.0.9, but does exist in
        // verssion 4.0 and possibly some intermediate versions
        String[] stringdata = new String[n];
        for (int i = 0; i < n; i++)
          stringdata[i] = p.getString(i * 8);
        data = stringdata;
        break;
      case OPAQUE:
      case STRUCTURE:
      default:
        throw new IllegalStateException();
    }
    array = Array.factory(dt, new int[] {n}, data);
    return array;
  }

  /**
   * Note that this only works for atomic base types;
   * structures will fail.
   */
  Array readVlen(int grpid, int varid, UserType userType, Section section) throws IOException {
    // Read all the vlen pointers
    int len = (int) section.computeSize();
    Nc4prototypes.Vlen_t[] vlen = new Nc4prototypes.Vlen_t[len];
    int ret = nc4.nc_get_var(grpid, varid, vlen);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    // Compute rank up to the first VLEN
    int prefixrank = 0;
    for (; prefixrank < section.getRank(); prefixrank++) {
      if (section.getRange(prefixrank) == Range.VLEN)
        break;
    }

    ConvertedType ctype = convertDataType(userType.baseTypeid);
    // ArrayObject.D1 vlenArray = new ArrayObject.D1( dtype, len);

    // Collect the vlen's data arrays
    Array[] data = new Array[len];
    switch (userType.baseTypeid) { // LOOK not complete
      case Nc4prototypes.NC_UINT:
      case Nc4prototypes.NC_INT:
        for (int i = 0; i < len; i++) {
          int slen = vlen[i].len;
          // Coverity[FB.NP_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD]
          int[] ba = vlen[i].p.getIntArray(0, slen);
          data[i] = Array.factory(ctype.dt, new int[] {slen}, ba);
        }
        break;
      case Nc4prototypes.NC_USHORT:
      case Nc4prototypes.NC_SHORT:
        for (int i = 0; i < len; i++) {
          int slen = vlen[i].len;
          // Coverity[FB.NP_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD]
          short[] ba = vlen[i].p.getShortArray(0, slen);
          data[i] = Array.factory(ctype.dt, new int[] {slen}, ba);
        }
        break;
      case Nc4prototypes.NC_FLOAT:
        for (int i = 0; i < len; i++) {
          int slen = vlen[i].len;
          // Coverity[FB.NP_UNWRITTEN_PUBLIC_OR_PROTECTED_FIELD]
          float[] ba = vlen[i].p.getFloatArray(0, slen);
          data[i] = Array.factory(DataType.FLOAT, new int[] {slen}, ba);
        }
        break;
      default:
        throw new UnsupportedOperationException("Vlen type " + userType.baseTypeid + " = " + ctype);
    }

    if (prefixrank == 0) { // if scalar, return just the len Array
      return data[0];
    } // else if (prefixrank == 1)
      // return Array.makeObjectArray(ctype.dt, data[0].getClass(), new int[]{len}, data);
      // return Array.makeVlenArray(new int[]{len}, data);

    // Otherwise create and fill in an n-dimensional Array Of Arrays
    int[] shape = new int[prefixrank];
    for (int i = 0; i < prefixrank; i++)
      shape[i] = section.getRange(i).length();

    // Array ndimarray = Array.makeObjectArray(ctype.dt, Array.class, shape, null);
    Array ndimarray = Array.makeVlenArray(shape, data);
    // Transfer the elements of data into the n-dim arrays
    // IndexIterator iter = ndimarray.getIndexIterator();
    // for (int i = 0; iter.hasNext(); i++) {
    // iter.setObjectNext(data[i]);
    // }
    return ndimarray;
  }

  // opaques use ArrayObjects of ByteBuffer
  private Array readOpaque(int grpid, int varid, Section section, int size) throws IOException {
    int ret;
    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    SizeT[] stride = convertSizeT(section.getStride());
    int len = (int) section.computeSize();

    byte[] bbuff = new byte[len * size];
    ret = nc4.nc_get_vars(grpid, varid, origin, shape, stride, bbuff);
    if (DEBUG)
      dumpbytes(bbuff, 0, bbuff.length, "readOpaque");
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    int[] intshape;

    if (shape != null) {
      // fix: this is ignoring the rank of section.
      // was: ArrayObject values = new ArrayObject(ByteBuffer.class, new int[]{len});
      intshape = new int[shape.length];
      for (int i = 0; i < intshape.length; i++) {
        intshape[i] = shape[i].intValue();
      }
    } else
      intshape = new int[] {1};

    Array values = Array.factory(DataType.OPAQUE, intshape);
    int count = 0;
    IndexIterator ii = values.getIndexIterator();
    while (ii.hasNext()) {
      ii.setObjectNext(ByteBuffer.wrap(bbuff, count * size, size));
      count++;
    }
    return values;
  }

  /*
   * private Array readEnum(int grpid, int varid, int baseType, int len, int[] shape)
   * throws IOException, InvalidRangeException
   * {
   * int ret;
   * 
   * ConvertedType ctype = convertDataType(baseType);
   * int elemSize = ctype.dt.getSize();
   * 
   * ByteBuffer bb = ByteBuffer.allocate(len * elemSize);
   * ret = nc4.nc_get_var(grpid, varid, bb);
   * if(ret != 0)
   * throw new IOException(ret+": "+nc4.nc_strerror(ret)) ;
   * 
   * switch (baseType) {
   * case NCLibrary.NC_BYTE:
   * case NCLibrary.NC_UBYTE:
   * return Array.factory( DataType.BYTE, shape, bb.array());
   * 
   * case NCLibrary.NC_SHORT:
   * case NCLibrary.NC_USHORT:
   * ShortBuffer sb = bb.asShortBuffer();
   * return Array.factory( DataType.BYTE, shape, sb.array());
   * 
   * case NCLibrary.NC_INT:
   * case NCLibrary.NC_UINT:
   * IntBuffer ib = bb.asIntBuffer();
   * return Array.factory( DataType.BYTE, shape, ib.array());
   * }
   * 
   * return null;
   * }
   */

  private boolean isUnsigned(int type) {
    return (type == Nc4prototypes.NC_UBYTE) || (type == Nc4prototypes.NC_USHORT) || (type == Nc4prototypes.NC_UINT)
        || (type == Nc4prototypes.NC_UINT64);
  }

  private boolean isVlen(int type) {
    UserType userType = userTypes.get(type);
    return (userType != null) && (userType.typeClass == Nc4prototypes.NC_VLEN);
  }

  private boolean isStride1(int[] strides) {
    if (strides == null)
      return true;
    for (int stride : strides) {
      if (stride != 1)
        return false;
    }
    return true;
  }

  private SizeT[] convertSizeT(int[] from) {
    if (from.length == 0)
      return null;
    SizeT[] to = new SizeT[from.length];
    for (int i = 0; i < from.length; i++)
      to[i] = new SizeT(from[i]);
    return to;
  }

  public static String show(SizeT[] inta) {
    if (inta == null)
      return "null";
    Formatter f = new Formatter();
    for (SizeT i : inta)
      f.format("%d, ", i.longValue());
    return f.toString();
  }

  // Cannot be static because it references non-static parent class members
  // Coverity[FB.SIC_INNER_SHOULD_BE_STATIC]
  private static class ConvertedType {
    DataType dt;
    // boolean isUnsigned;
    boolean isVlen;

    ConvertedType(DataType dt) {
      this.dt = dt;
    }
  }

  private int convertDataType(DataType dt) {
    switch (dt) {
      case BYTE:
        return Nc4prototypes.NC_BYTE;
      case UBYTE:
        return Nc4prototypes.NC_UBYTE;
      case CHAR:
        return Nc4prototypes.NC_CHAR;
      case DOUBLE:
        return Nc4prototypes.NC_DOUBLE;
      case FLOAT:
        return Nc4prototypes.NC_FLOAT;
      case INT:
        return Nc4prototypes.NC_INT;
      case UINT:
        return Nc4prototypes.NC_UINT;
      case LONG:
        return Nc4prototypes.NC_INT64;
      case ULONG:
        return Nc4prototypes.NC_UINT64;
      case SHORT:
        return Nc4prototypes.NC_SHORT;
      case USHORT:
        return Nc4prototypes.NC_USHORT;
      case STRING:
        return Nc4prototypes.NC_STRING;
      case ENUM1:
      case ENUM2:
      case ENUM4:
        return Nc4prototypes.NC_ENUM;
      case OPAQUE:
        log.warn("Skipping Opaque Type");
        return -1;
      case STRUCTURE:
        return Nc4prototypes.NC_COMPOUND;
    }
    throw new IllegalArgumentException("unimplemented type == " + dt);
  }


  private ConvertedType convertDataType(int type) {
    switch (type) {
      case Nc4prototypes.NC_BYTE:
        return new ConvertedType(DataType.BYTE);

      case Nc4prototypes.NC_UBYTE:
        return new ConvertedType(DataType.UBYTE);

      case Nc4prototypes.NC_CHAR:
        return new ConvertedType(DataType.CHAR);

      case Nc4prototypes.NC_SHORT:
        return new ConvertedType(DataType.SHORT);

      case Nc4prototypes.NC_USHORT:
        return new ConvertedType(DataType.USHORT);

      case Nc4prototypes.NC_INT:
        return new ConvertedType(DataType.INT);

      case Nc4prototypes.NC_UINT:
        return new ConvertedType(DataType.UINT);

      case Nc4prototypes.NC_INT64:
        return new ConvertedType(DataType.LONG);

      case Nc4prototypes.NC_UINT64:
        return new ConvertedType(DataType.ULONG);

      case Nc4prototypes.NC_FLOAT:
        return new ConvertedType(DataType.FLOAT);

      case Nc4prototypes.NC_DOUBLE:
        return new ConvertedType(DataType.DOUBLE);

      case Nc4prototypes.NC_ENUM:
        return new ConvertedType(DataType.ENUM1); // LOOK width ??

      case Nc4prototypes.NC_STRING:
        return new ConvertedType(DataType.STRING);

      default:
        UserType userType = userTypes.get(type);
        if (userType == null)
          throw new IllegalArgumentException("unknown type == " + type);

        switch (userType.typeClass) {
          case Nc4prototypes.NC_ENUM:
            switch (userType.size) {
              case 1:
                return new ConvertedType(DataType.ENUM1);
              case 2:
                return new ConvertedType(DataType.ENUM2);
              case 4:
                return new ConvertedType(DataType.ENUM4);
              default:
                throw new IllegalArgumentException("enum unknown size == " + userType);
            }

          case Nc4prototypes.NC_COMPOUND:
            return new ConvertedType(DataType.STRUCTURE);

          case Nc4prototypes.NC_OPAQUE:
            return new ConvertedType(DataType.OPAQUE);

          case Nc4prototypes.NC_VLEN:
            ConvertedType result = convertDataType(userType.baseTypeid);
            result.isVlen = true;
            return result;
        }
        throw new IllegalArgumentException("unknown type == " + type);
    }
  }

  private String getDataTypeName(int type) {
    switch (type) {
      case Nc4prototypes.NC_BYTE:
        return "byte";
      case Nc4prototypes.NC_UBYTE:
        return "ubyte";
      case Nc4prototypes.NC_CHAR:
        return "char";
      case Nc4prototypes.NC_SHORT:
        return "short";
      case Nc4prototypes.NC_USHORT:
        return "ushort";
      case Nc4prototypes.NC_INT:
        return "int";
      case Nc4prototypes.NC_UINT:
        return "uint";
      case Nc4prototypes.NC_INT64:
        return "long";
      case Nc4prototypes.NC_UINT64:
        return "ulong";
      case Nc4prototypes.NC_FLOAT:
        return "float";
      case Nc4prototypes.NC_DOUBLE:
        return "double";
      case Nc4prototypes.NC_ENUM:
        return "enum";
      case Nc4prototypes.NC_STRING:
        return "string";
      case Nc4prototypes.NC_COMPOUND:
        return "struct";
      case Nc4prototypes.NC_OPAQUE:
        return "opaque";
      case Nc4prototypes.NC_VLEN:
        return "vlen";

      default:
        UserType userType = userTypes.get(type);
        if (userType == null)
          return "unknown type " + type;

        switch (userType.typeClass) {
          case Nc4prototypes.NC_ENUM:
            return "userType-enum";
          case Nc4prototypes.NC_COMPOUND:
            return "userType-struct";
          case Nc4prototypes.NC_OPAQUE:
            return "userType-opaque";
          case Nc4prototypes.NC_VLEN:
            return "userType-vlen";
        }
        return "unknown userType " + userType.typeClass;
    }
  }

  //////////////////////////////////////////////////////////////////////
  // writing data

  @Override
  public void create(String filename, NetcdfFile ncfile, int extra, long preallocateSize, boolean largeFile)
      throws IOException {
    if (!isClibraryPresent()) {
      throw new UnsupportedOperationException("Couldn't load NetCDF C library (see log for details).");
    }

    this.ncfile = ncfile;

    // finish any structures
    ncfile.finish();

    // create new file
    log.debug("create {}", ncfile.getLocation());
    int ret;

    /*
     * IntByReference oldFormat = new IntByReference();
     * int ret = nc4.nc_set_default_format(defineFormat(), oldFormat);
     * if (ret != 0)
     * throw new IOException(ret + ": " + nc4.nc_strerror(ret));
     */

    IntByReference ncidp = new IntByReference();
    ret = nc4.nc_create(filename, createMode(), ncidp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    isClosed = false;
    ncid = ncidp.getValue();

    _setFill();

    createGroup(new Group4(ncid, ncfile.getRootGroup(), null));

    // done with define mode
    nc4.nc_enddef(ncid);
    if (debugWrite)
      System.out.printf("create done%n%n");
  }


  /*
   * cmode The creation mode flag. The following flags are available:
   * NC_NOCLOBBER (do not overwrite existing file),
   * NC_SHARE (limit write caching - netcdf classic files onlt),
   * NC_64BIT_OFFSET (create 64-bit offset file),
   * NC_NETCDF4 (create netCDF-4/HDF5 file),
   * NC_CLASSIC_MODEL (enforce netCDF classic mode on netCDF-4/HDF5 files),
   * NC_DISKLESS (store data only in memory),
   * NC_MMAP (use MMAP for NC_DISKLESS), and
   * NC_WRITE. See discussion below.
   */
  private int createMode() {
    int ret = NC_CLOBBER;
    switch (version) {
      case netcdf4:
        ret |= NC_NETCDF4;
        break;
      case netcdf4_classic:
        ret |= NC_NETCDF4 | NC_CLASSIC_MODEL;
        break;
    }

    return ret;
  }

  /*
   * #define NC_FORMAT_CLASSIC (1)
   * #define NC_FORMAT_64BIT (2)
   * #define NC_FORMAT_NETCDF4 (3)
   * #define NC_FORMAT_NETCDF4_CLASSIC (4)
   */
  private int defineFormat() {
    switch (version) {
      case netcdf4:
        return Nc4prototypes.NC_FORMAT_NETCDF4;
      case netcdf4_classic:
        return Nc4prototypes.NC_FORMAT_NETCDF4_CLASSIC;
      case netcdf3c:
        return Nc4prototypes.NC_FORMAT_CLASSIC;
      case netcdf3c64:
        return Nc4prototypes.NC_FORMAT_64BIT;
    }
    throw new IllegalStateException("version = " + version);
  }

  private void createGroup(Group4 g4) throws IOException {
    groupHash.put(g4.g, g4.grpid);
    g4.dimHash = new HashMap<>();

    // attributes
    for (Attribute att : g4.g.attributes())
      writeAttribute(g4.grpid, Nc4prototypes.NC_GLOBAL, att, null);

    // dimensions
    for (Dimension dim : g4.g.getDimensions()) {
      int dimLength = dim.isUnlimited() ? Nc4prototypes.NC_UNLIMITED : dim.getLength();
      int dimid = addDimension(g4.grpid, dim.getShortName(), dimLength);
      g4.dimHash.put(dim, dimid);

      if (debugWrite)
        System.out.printf(" create dim '%s' len=%d id=%d in group %d%n", dim.getShortName(), dim.getLength(), dimid,
            g4.grpid);
    }

    // enums
    for (EnumTypedef en : g4.g.getEnumTypedefs()) {
      createEnumType(g4, en);
    }

    // a type must be created for each structure.
    // LOOK we should look for variables with the same structure type.
    for (Variable v : g4.g.getVariables()) {
      if (v.getDataType() == DataType.STRUCTURE) {
        createCompoundType(g4, (Structure) v);
      }
    }

    // variables
    for (Variable v : g4.g.getVariables()) {
      createVariable(g4, v);
    }

    // groups
    for (Group nested : g4.g.getGroups()) {
      IntByReference grpidp = new IntByReference();
      int ret = nc4.nc_def_grp(g4.grpid, nested.getShortName(), grpidp);

      if (ret != 0)
        throw new IOException(ret + ": " + nc4.nc_strerror(ret));
      int nestedId = grpidp.getValue();
      createGroup(new Group4(nestedId, nested, g4));
    }
  }

  private void createVariable(Group4 g4, Variable v) throws IOException {
    int[] dimids = new int[v.getRank()];
    int count = 0;
    for (Dimension d : v.getDimensions()) {
      int dimid;
      if (!d.isShared()) {
        dimid = addDimension(g4.grpid, v.getShortName() + "_Dim" + count, d.getLength());
      } else {
        dimid = findDimensionId(g4, d);
      }
      if (debugDim)
        System.out.printf("  use dim '%s' (%d) in variable '%s'%n", d.getShortName(), dimid, v.getShortName());
      dimids[count++] = dimid;
    }

    int typid;
    Vinfo vinfo;
    if (v instanceof Structure) { // g4 and typid was stored in vinfo in createCompoundType
      vinfo = (Vinfo) v.getSPobject();
      typid = vinfo.typeid;

    } else if (v.getDataType().isEnum()) {
      EnumTypedef en = v.getEnumTypedef();
      UserType ut = (UserType) en.annotation(UserType.class);
      typid = ut.typeid;
      vinfo = new Vinfo(g4, -1, typid);
    } else if (v.getDataType() == DataType.OPAQUE) {
      typid = convertDataType(v.getDataType());
      if (typid < 0)
        return; // not implemented yet
      vinfo = new Vinfo(g4, -1, typid);
    } else {
      typid = convertDataType(v.getDataType());
      if (typid < 0)
        return; // not implemented yet
      vinfo = new Vinfo(g4, -1, typid);
    }

    if (debugWrite)
      System.out.printf("adding variable %s (typeid %d) %n", v.getShortName(), typid);
    IntByReference varidp = new IntByReference();
    int ret = nc4.nc_def_var(g4.grpid, v.getShortName(), new SizeT(typid), dimids.length, dimids, varidp);
    if (ret != 0)
      throw new IOException("ret=" + ret + " err='" + nc4.nc_strerror(ret) + "' on\n" + v);
    int varid = varidp.getValue();
    vinfo.varid = varid;
    if (debugWrite)
      System.out.printf("added variable %s (grpid %d varid %d) %n", v, vinfo.g4.grpid, vinfo.varid);

    if (version.isNetdf4format() && v.getRank() > 0) {
      boolean isChunked = chunker.isChunked(v);
      int storage = isChunked ? Nc4prototypes.NC_CHUNKED : Nc4prototypes.NC_CONTIGUOUS;
      SizeT[] chunking;
      if (isChunked) {
        long[] lchunks = chunker.computeChunking(v);
        chunking = new SizeT[lchunks.length];
        for (int i = 0; i < lchunks.length; i++)
          chunking[i] = new SizeT(lchunks[i]);
      } else
        chunking = new SizeT[v.getRank()];

      ret = nc4.nc_def_var_chunking(g4.grpid, varid, storage, chunking);
      if (ret != 0) {
        throw new IOException(nc4.nc_strerror(ret) + " nc_def_var_chunking on variable " + v.getFullName());
      }

      if (isChunked) {
        int deflateLevel = chunker.getDeflateLevel(v);
        int deflate = deflateLevel > 0 ? 1 : 0;
        int shuffle = chunker.isShuffle(v) ? 1 : 0;
        if (deflateLevel > 0) {
          ret = nc4.nc_def_var_deflate(g4.grpid, varid, shuffle, deflate, deflateLevel);
          if (ret != 0)
            throw new IOException(nc4.nc_strerror(ret));
        }
      }
    }

    v.setSPobject(vinfo);

    if (v instanceof Structure) {
      createCompoundMemberAtts(g4.grpid, varid, (Structure) v);
    }

    for (Attribute att : v.attributes()) {
      writeAttribute(g4.grpid, varid, att, v);
    }
  }


  /////////////////////////////////////
  // Enum types

  /*
   * Enum data types can be defined for netCDF-4/HDF5 format files.
   * As with CDM, they are a set of (id,int) values.
   * 
   * Create an enum type. Provide an ncid, a name, and base type
   * (some sort of int type).
   * After calling this function, fill out the type with repeated calls to nc_insert_enum.
   * Call nc_insert_enum once for each (id,int) you wish to insert into the enum.
   */
  private void createEnumType(Group4 g4, EnumTypedef en) throws IOException {
    IntByReference typeidp = new IntByReference();
    String name = en.getShortName();
    DataType enumbase = en.getBaseType();
    int basetype = NC_NAT;
    if (enumbase == DataType.ENUM1)
      basetype = Nc4prototypes.NC_BYTE;
    else if (enumbase == DataType.ENUM2)
      basetype = Nc4prototypes.NC_SHORT;
    else if (enumbase == DataType.ENUM4)
      basetype = Nc4prototypes.NC_INT;
    int ret = nc4.nc_def_enum(g4.grpid, basetype, name, typeidp);
    if (ret != 0)
      throw new IOException(nc4.nc_strerror(ret) + " on\n" + en);
    int typeid = typeidp.getValue();
    if (DEBUG)
      System.out.printf("added enum type %s (typeid %d)%n", name, typeid);
    Map<Integer, String> emap = en.getMap();
    for (Map.Entry<Integer, String> entry : emap.entrySet()) {
      IntByReference val = new IntByReference(entry.getKey());
      ret = nc4.nc_insert_enum(g4.grpid, typeid, entry.getValue(), val);
      if (ret != 0)
        throw new IOException(nc4.nc_strerror(ret) + " on\n" + entry.getValue());
      if (DEBUG)
        System.out.printf(" added enum type member %s: %d%n", entry.getValue(), entry.getKey());
    }
    // keep track of the User Defined types
    UserType ut = new UserType(g4.grpid, typeid, name, en.getBaseType().getSize(), basetype, emap.size(), NC_ENUM);
    userTypes.put(typeid, ut);
    en.annotate(UserType.class, ut); // dont know the varid yet
  }

  /////////////////////////////////////
  // compound types

  /*
   * Compound data types can be defined for netCDF-4/HDF5 format files. A compound datatype is similar to a struct in C
   * and contains a collection of one or more
   * atomic or user-defined types. The netCDF-4 compound data must comply with the properties and constraints of the
   * HDF5 compound data type in terms of which it is implemented.
   * 
   * In summary these are:
   * 
   * It has a fixed total size.
   * It consists of zero or more named members that do not overlap with other members.
   * Each member has a name distinct from other members.
   * Each member has its own datatype.
   * Each member is referenced by an index number between zero and N-1, where N is the number of members in the compound
   * datatype.
   * Each member has a fixed byte offset, which is the first byte (smallest byte address) of that member in the compound
   * datatype.
   * In addition to other other user-defined data types or atomic datatypes, a member can be a small fixed-size array of
   * any type with up to
   * four fixed-size dimensions (not associated with named netCDF dimensions).
   * 
   * Create a compound type. Provide an ncid, a name, and a total size (in bytes) of one element of the completed
   * compound type.
   * After calling this function, fill out the type with repeated calls to nc_insert_compound (see nc_insert_compound).
   * Call nc_insert_compound once for each field you wish to insert into the compound type.
   */
  private void createCompoundType(Group4 g4, Structure s) throws IOException {
    IntByReference typeidp = new IntByReference();
    long size = s.getElementSize();
    String name = s.getShortName() + "_t";
    int ret = nc4.nc_def_compound(g4.grpid, new SizeT(size), name, typeidp);
    if (ret != 0)
      throw new IOException(nc4.nc_strerror(ret) + " on\n" + s);
    int typeid = typeidp.getValue();
    if (debugCompound)
      System.out.printf("added compound type %s (typeid %d) size=%d %n", name, typeid, size);

    List<Field> flds = new ArrayList<>();
    int fldidx = 0;
    long offset = 0;
    for (Variable v : s.getVariables()) {
      if (v.getDataType() == DataType.STRING)
        continue;

      int field_typeid = convertDataType(v.getDataType());
      if (v.isScalar())
        ret = nc4.nc_insert_compound(g4.grpid, typeid, v.getShortName(), new SizeT(offset), field_typeid);
      else
        ret = nc4.nc_insert_array_compound(g4.grpid, typeid, v.getShortName(), new SizeT(offset), field_typeid,
            v.getRank(), v.getShape());

      if (ret != 0)
        throw new IOException(nc4.nc_strerror(ret) + " on\n" + s.getShortName());

      Field fld =
          new Field(g4.grpid, typeid, fldidx, v.getShortName(), (int) offset, field_typeid, v.getRank(), v.getShape());
      flds.add(fld);
      if (debugCompound)
        System.out.printf(" added compound type member %s (%s) offset=%d size=%d%n", v.getShortName(), v.getDataType(),
            offset, v.getElementSize() * v.getSize());

      offset += v.getElementSize() * v.getSize();
      fldidx++;
    }

    s.setSPobject(new Vinfo(g4, -1, typeidp.getValue())); // dont know the varid yet

    // keep track of the User Defined types
    UserType ut = new UserType(g4.grpid, typeid, name, size, 0, (long) fldidx, NC_COMPOUND);
    userTypes.put(typeid, ut);
    ut.setFields(flds); // LOOK: These were already set in the UserType ctor.
  }

  private void createCompoundMemberAtts(int grpid, int varid, Structure s) throws IOException {

    // count size of attribute values
    int sizeAtts = 0;
    for (Variable m : s.getVariables()) {
      for (Attribute att : m.attributes()) {
        int elemSize;
        if (att.isString()) {
          String val = att.getStringValue();
          elemSize = val.getBytes(StandardCharsets.UTF_8).length;
          if (elemSize == 0)
            elemSize = 1;
        } else {
          elemSize = att.getDataType().getSize() * att.getLength();
        }
        sizeAtts += elemSize;
      }
    }
    if (sizeAtts == 0)
      return; // no atts; */

    // create the compound type for member_atts_t
    IntByReference typeidp = new IntByReference();
    String typeName = "_" + s.getShortName() + "_field_atts_t";
    int ret = nc4.nc_def_compound(grpid, new SizeT(sizeAtts), typeName, typeidp);
    if (ret != 0)
      throw new IOException(nc4.nc_strerror(ret) + " on\n" + s);
    int typeid = typeidp.getValue();
    if (debugCompound)
      System.out.printf("added compound member att type %s (typeid %d) grpid %d size=%d %n", typeName, typeid, grpid,
          sizeAtts); // */

    // add the fields to the member_atts_t and place the values in a ByteBuffer
    ByteBuffer bb = ByteBuffer.allocate(sizeAtts);
    bb.order(ByteOrder.nativeOrder());
    for (Variable m : s.getVariables()) {
      for (Attribute att : m.attributes()) {
        // add the fields to the member_atts_t
        String memberName = m.getShortName() + ":" + att.getShortName();
        int field_typeid = att.isString() ? Nc4prototypes.NC_CHAR : convertDataType(att.getDataType()); // LOOK override
                                                                                                        // String with
                                                                                                        // CHAR

        if (att.isString()) { // String gets turned into array of char; otherwise no way to pass in
          String val = att.getStringValue();
          int len = val.getBytes(StandardCharsets.UTF_8).length;
          if (len == 0)
            len = 1;
          ret = nc4.nc_insert_array_compound(grpid, typeid, memberName, new SizeT(bb.position()), field_typeid, 1,
              new int[] {len});

        } else if (!att.isArray())
          ret = nc4.nc_insert_compound(grpid, typeid, memberName, new SizeT(bb.position()), field_typeid);
        else
          ret = nc4.nc_insert_array_compound(grpid, typeid, memberName, new SizeT(bb.position()), field_typeid, 1,
              new int[] {att.getLength()});

        if (ret != 0)
          throw new IOException(nc4.nc_strerror(ret) + " on\n" + s.getShortName());

        if (debugCompound) {
          int elemSize;
          if (att.isString()) {
            String val = att.getStringValue();
            elemSize = val.getBytes(StandardCharsets.UTF_8).length;
          } else {
            elemSize = att.getDataType().getSize() * att.getLength();
          }
          System.out.printf(" added compound att member %s type %s (%d) offset=%d elemSize=%d%n", memberName,
              att.getDataType(), field_typeid, bb.position(), elemSize);
        }

        // place the values in a ByteBuffer
        if (att.isString()) {
          String val = att.getStringValue();
          byte[] sby = val.getBytes(StandardCharsets.UTF_8);
          for (byte b : sby)
            bb.put(b);
          if (sby.length == 0)
            bb.put((byte) 0); // empyy string has a 0
        } else {
          for (int i = 0; i < att.getLength(); i++) {
            switch (att.getDataType()) {
              case BYTE:
                bb.put(att.getNumericValue(i).byteValue());
                break;
              case CHAR:
                bb.put(att.getNumericValue(i).byteValue()); // ??
                break;
              case DOUBLE:
                bb.putDouble(att.getNumericValue(i).doubleValue());
                break;
              case FLOAT:
                bb.putFloat(att.getNumericValue(i).floatValue());
                break;
              case INT:
                bb.putInt(att.getNumericValue(i).intValue());
                break;
              case LONG:
                bb.putLong(att.getNumericValue(i).longValue());
                break;
              case SHORT:
                bb.putShort(att.getNumericValue(i).shortValue());
                break;
              default:
                throw new IllegalStateException("Att type " + att.getDataType() + " not found");
            }
          }
        }
      } // loop over atts
    } // loop over vars */


    // now write that attribute on the variable
    String attName = "_field_atts";
    ret = nc4.nc_put_att(grpid, varid, attName, typeid, new SizeT(1), bb.array());
    if (ret != 0)
      throw new IOException(nc4.nc_strerror(ret) + " on\n" + s.getShortName());
    if (debugCompound)
      System.out.printf("write att %s (typeid %d) size=%d %n", attName, typeid, sizeAtts); // */

  }

  //////////////////////////////////////////////////

  private Integer findDimensionId(Group4 g4, Dimension d) {
    if (g4 == null)
      return null;

    Integer dimid = g4.dimHash.get(d);
    if (dimid == null) {
      dimid = findDimensionId(g4.parent, d); // search in parent
    }

    return dimid;
  }

  private int addDimension(int grpid, String name, int length) throws IOException {
    IntByReference dimidp = new IntByReference();
    int ret = nc4.nc_def_dim(grpid, name, new SizeT(length), dimidp);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
    if (debugDim)
      System.out.printf("add dimension %s len=%d%n", name, length);
    return dimidp.getValue();
  }


  private void writeAttribute(int grpid, int varid, Attribute att, Variable v) throws IOException {
    if (v != null && att.getShortName().equals(CDM.FILL_VALUE)) {
      if (att.getLength() != 1) {
        log.warn("_FillValue length must be one on var = {}", v.getFullName());
        return;
      }
      if (att.getDataType() != v.getDataType()) {
        // Special case hack for _FillValue type match for char typed variables
        if (att.getDataType() != DataType.STRING || v.getDataType() != DataType.CHAR) {
          log.warn("_FillValue type ({}) does not agree with variable '{}' type ({}).", att.getDataType(),
              v.getFullName(), v.getDataType());
          return;
        } // else char typed variable with string typed _FillValue
      }
    }

    // dont propagate these - handled internally
    if (att.getShortName().equals(H5header.HDF5_CLASS))
      return;
    if (att.getShortName().equals(H5header.HDF5_DIMENSION_LIST))
      return;
    if (att.getShortName().equals(H5header.HDF5_DIMENSION_SCALE))
      return;
    if (att.getShortName().equals(H5header.HDF5_DIMENSION_LABELS))
      return;
    if (att.getShortName().equals(CDM.CHUNK_SIZES))
      return;
    if (att.getShortName().equals(CDM.COMPRESS))
      return;
    if (att.getShortName().equals(CDM.NCPROPERTIES))
      return;
    if (att.getShortName().equals(CDM.ISNETCDF4))
      return;

    int ret = 0;
    Array values = att.getValues();
    Object arrayStorage = null;
    if (values != null) {
      arrayStorage = values.getStorage();
    }
    switch (att.getDataType()) {
      case STRING: // problem may be that we are mapping char * atts to string type
        if (v != null && att.getShortName().equals(CDM.FILL_VALUE) && att.getLength() == 1
            && v.getDataType() == DataType.CHAR) {
          // special handling of _FillValue if v.getDataType() == CHAR
          byte[] svalb = att.getStringValue().getBytes(StandardCharsets.UTF_8);
          // if svalb is a zero length array, force it to be the null char
          if (svalb.length == 0)
            svalb = new byte[] {0};
          ret = nc4.nc_put_att_text(grpid, varid, att.getShortName(), new SizeT(svalb.length), svalb);
        } else { // String valued attribute
          if (this.version != NetcdfFileWriter.Version.netcdf4) {
            // Must write it as character typed attribute
            StringBuilder text = new StringBuilder();
            // Concatenate all the attribute strings
            for (int i = 0; i < att.getLength(); i++)
              text.append(att.getStringValue(i));
            byte[] svalb = text.toString().getBytes(StandardCharsets.UTF_8);
            if (svalb.length == 0)
              svalb = new byte[] {0};
            ret = nc4.nc_put_att_text(grpid, varid, att.getShortName(), new SizeT(svalb.length), svalb);
          } else { // Can write as string typed attribute
            String[] svalues = new String[att.getLength()];
            for (int i = 0; i < att.getLength(); i++)
              svalues[i] = (String) att.getValue(i);
            ret = nc4.nc_put_att_string(grpid, varid, att.getShortName(), new SizeT(att.getLength()), svalues);
          }
        }
        break;
      case UBYTE:
        ret = nc4.nc_put_att_uchar(grpid, varid, att.getShortName(), Nc4prototypes.NC_UBYTE, new SizeT(att.getLength()),
            (byte[]) arrayStorage);
        break;
      case BYTE:
        ret = nc4.nc_put_att_schar(grpid, varid, att.getShortName(), Nc4prototypes.NC_BYTE, new SizeT(att.getLength()),
            (byte[]) arrayStorage);
        break;
      case CHAR:
        ret = nc4.nc_put_att_text(grpid, varid, att.getShortName(), new SizeT(att.getLength()),
            IospHelper.convertCharToByte((char[]) arrayStorage));
        break;
      case DOUBLE:
        ret = nc4.nc_put_att_double(grpid, varid, att.getShortName(), Nc4prototypes.NC_DOUBLE,
            new SizeT(att.getLength()), (double[]) arrayStorage);
        break;
      case FLOAT:
        ret = nc4.nc_put_att_float(grpid, varid, att.getShortName(), Nc4prototypes.NC_FLOAT, new SizeT(att.getLength()),
            (float[]) arrayStorage);
        break;
      case UINT:
        ret = nc4.nc_put_att_uint(grpid, varid, att.getShortName(), Nc4prototypes.NC_UINT, new SizeT(att.getLength()),
            (int[]) arrayStorage);
        break;
      case INT:
        ret = nc4.nc_put_att_int(grpid, varid, att.getShortName(), Nc4prototypes.NC_INT, new SizeT(att.getLength()),
            (int[]) arrayStorage);
        break;
      case ULONG:
        ret = nc4.nc_put_att_ulonglong(grpid, varid, att.getShortName(), Nc4prototypes.NC_UINT64,
            new SizeT(att.getLength()), (long[]) arrayStorage);
        break;
      case LONG:
        ret = nc4.nc_put_att_longlong(grpid, varid, att.getShortName(), Nc4prototypes.NC_INT64,
            new SizeT(att.getLength()), (long[]) arrayStorage);
        break;
      case USHORT:
        ret = nc4.nc_put_att_ushort(grpid, varid, att.getShortName(), Nc4prototypes.NC_USHORT,
            new SizeT(att.getLength()), (short[]) arrayStorage);
        break;
      case SHORT:
        ret = nc4.nc_put_att_short(grpid, varid, att.getShortName(), Nc4prototypes.NC_SHORT, new SizeT(att.getLength()),
            (short[]) arrayStorage);
        break;
    }

    if (ret != 0) {
      String where = v != null ? "var " + v.getFullName() : "global or group attribute";
      throw new IOException(ret + " (" + nc4.nc_strerror(ret) + ") on attribute '" + att + "' on " + where);
    }

    if (debugWrite)
      System.out.printf("Add attribute to var %s == %s%n", (v == null) ? "global" : v.getFullName(), att.toString());
  }

  @Override
  public void writeData(Variable v2, Section section, Array values) throws IOException, InvalidRangeException {
    Vinfo vinfo = (Vinfo) v2.getSPobject();
    if (vinfo == null) {
      log.error("vinfo null for " + v2);
      throw new IllegalStateException("vinfo null for " + v2.getFullName());
    }
    // int vlen = (int) v2.getSize();
    // int len = (int) section.computeSize();
    // if (vlen == len) // entire array
    // writeDataAll(v2, vinfo.grpid, vinfo.varid, vinfo.typeid, values);
    // else
    writeData(v2, vinfo.g4.grpid, vinfo.varid, vinfo.typeid, section, values);
  }

  private void writeData(Variable v, int grpid, int varid, int typeid, Section section, Array values)
      throws IOException, InvalidRangeException {

    // general sectioning with strides
    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    SizeT[] stride = convertSizeT(section.getStride());
    boolean isUnsigned = isUnsigned(typeid);
    int sectionLen = (int) section.computeSize();

    Object data = values.get1DJavaArray(values.getDataType());

    switch (typeid) {

      case Nc4prototypes.NC_BYTE:
      case Nc4prototypes.NC_UBYTE:
        byte[] valb = (byte[]) data;
        assert valb.length == sectionLen;
        int ret = isUnsigned ? nc4.nc_put_vars_uchar(grpid, varid, origin, shape, stride, valb)
            : nc4.nc_put_vars_schar(grpid, varid, origin, shape, stride, valb);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        break;

      case Nc4prototypes.NC_CHAR:
        char[] valc = (char[]) data; // chars are lame
        assert valc.length == sectionLen;

        valb = IospHelper.convertCharToByte(valc);
        ret = nc4.nc_put_vars_text(grpid, varid, origin, shape, stride, valb);
        // ret = nc4.nc_put_vara_text(grpid, varid, origin, shape, valb);

        if (ret != 0) {
          throw new IOException(nc4.nc_strerror(ret));
        }
        break;

      case Nc4prototypes.NC_DOUBLE:
        double[] vald = (double[]) data;
        assert vald.length == sectionLen;
        ret = nc4.nc_put_vars_double(grpid, varid, origin, shape, stride, vald);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        break;

      case Nc4prototypes.NC_FLOAT:
        float[] valf = (float[]) data;
        assert valf.length == sectionLen;
        ret = nc4.nc_put_vars_float(grpid, varid, origin, shape, stride, valf);
        if (ret != 0) {
          // log.error("{} on var {}", nc4.nc_strerror(ret), v);
          // return;
          throw new IOException(nc4.nc_strerror(ret));
        }
        break;

      case Nc4prototypes.NC_UINT:
      case Nc4prototypes.NC_INT:
        int[] vali = (int[]) data;
        assert vali.length == sectionLen;
        ret = isUnsigned ? nc4.nc_put_vars_uint(grpid, varid, origin, shape, stride, vali)
            : nc4.nc_put_vars_int(grpid, varid, origin, shape, stride, vali);

        if (ret != 0) {
          // log.error("{} on var {}", nc4.nc_strerror(ret), v);
          // return;
          throw new IOException(nc4.nc_strerror(ret));
        }
        break;

      case Nc4prototypes.NC_UINT64:
      case Nc4prototypes.NC_INT64:
        long[] vall = (long[]) data;
        assert vall.length == sectionLen;
        ret = isUnsigned ? nc4.nc_put_vars_ulonglong(grpid, varid, origin, shape, stride, vall)
            : nc4.nc_put_vars_longlong(grpid, varid, origin, shape, stride, vall);

        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        break;

      case Nc4prototypes.NC_USHORT:
      case Nc4prototypes.NC_SHORT:
        short[] vals = (short[]) data;
        assert vals.length == sectionLen;
        ret = isUnsigned ? nc4.nc_put_vars_ushort(grpid, varid, origin, shape, stride, vals)
            : nc4.nc_put_vars_short(grpid, varid, origin, shape, stride, vals);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        break;

      case Nc4prototypes.NC_STRING:
        String[] valss = convertStringData(data);
        assert valss.length == sectionLen;
        ret = nc4.nc_put_vars_string(grpid, varid, origin, shape, stride, valss);
        if (ret != 0)
          throw new IOException(ret + ": " + nc4.nc_strerror(ret));
        break;

      default:
        UserType userType = userTypes.get(typeid);
        if (userType == null)
          throw new IOException("Unknown userType == " + typeid);
        switch (userType.typeClass) {
          case NC_ENUM:
            ret = writeEnumData(v, userType, grpid, varid, typeid, section, values);
            if (ret != 0) {
              // log.error("{} on var {}", nc4.nc_strerror(ret), v);
              // return;
              throw new IOException(nc4.nc_strerror(ret));
            }
            break;
          case NC_COMPOUND:
            writeCompoundData((Structure) v, userType, grpid, varid, typeid, section, (ArrayStructure) values);
            return;
          case NC_VLEN:
          case NC_OPAQUE:
          default:
            throw new IOException("Unsupported writing of userType= " + userType);
        }
    }
    if (debugWrite)
      System.out.printf("OK writing var %s%n", v);
  }

  private int writeEnumData(Variable v, UserType userType, int grpid, int varid, int typeid, Section section,
      Array values) throws IOException, InvalidRangeException {
    int ret = 0;
    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    boolean isUnsigned = isUnsigned(typeid);
    int sectionLen = (int) section.computeSize();

    assert values.getSize() == sectionLen;

    int[] secStride = section.getStride();
    boolean stride1 = isStride1(secStride);

    ByteBuffer bb = values.getDataAsByteBuffer(ByteOrder.nativeOrder());
    byte[] data = bb.array();
    if (stride1) {
      ret = nc4.nc_put_vara(grpid, varid, origin, shape, data);
    } else {
      SizeT[] stride = convertSizeT(secStride);
      ret = nc4.nc_put_vars(grpid, varid, origin, shape, stride, data);
    }
    return ret;
  }


  /*
   * Here is an example of using nc_put_vars_float to write – from an internal array – every other point of a netCDF
   * variable named rh which is described by the C declaration float rh[4][6] (note the size of the dimensions):
   * 
   * #include <netcdf.h>
   * ...
   * #define NDIM 2 /* rank of netCDF variable
   * int ncid; /* netCDF ID
   * int status; /* error status *
   * int rhid; /* variable ID *
   * static size_t start[NDIM] /* netCDF variable start point: *
   * = {0, 0}; /* first element *
   * static size_t count[NDIM] /* size of internal array: entire *
   * = {2, 3}; /* (subsampled) netCDF variable *
   * static ptrdiff_t stride[NDIM] /* variable subsampling intervals: *
   * = {2, 2}; /* access every other netCDF element *
   * float rh[2][3]; /* note subsampled sizes for netCDF variable dimensions LOOK [][] not [,]
   * ...
   * status = nc_open("foo.nc", NC_WRITE, &ncid);
   * if (status != NC_NOERR) handle_error(status);
   * ...
   * status = nc_inq_varid(ncid, "rh", &rhid);
   * if (status != NC_NOERR) handle_error(status);
   * ...
   * status = nc_put_vars_float(ncid, rhid, start, count, stride, rh);
   * if (status != NC_NOERR) handle_error(status);
   */
  private void writeCompoundData(Structure s, UserType userType, int grpid, int varid, int typeid, Section section,
      ArrayStructure values) throws IOException, InvalidRangeException {

    SizeT[] origin = convertSizeT(section.getOrigin());
    SizeT[] shape = convertSizeT(section.getShape());
    SizeT[] stride = convertSizeT(section.getStride());

    ArrayStructureBB valuesBB = StructureDataDeep.copyToArrayBB(s, values, ByteOrder.nativeOrder()); // LOOK embedded
                                                                                                     // strings getting
                                                                                                     // lost ??
    ByteBuffer bbuff = valuesBB.getByteBuffer();

    if (debugCompound)
      System.out.printf("writeCompoundData variable %s (grpid %d varid %d) %n", s.getShortName(), grpid, varid);

    // write the data
    // int ret = nc4.nc_put_var(grpid, varid, bbuff);
    int ret;
    if (section.isStrided())
      ret = nc4.nc_put_vars(grpid, varid, origin, shape, stride, bbuff.array());
    else
      ret = nc4.nc_put_vara(grpid, varid, origin, shape, bbuff.array());
    if (ret != 0)
      throw new IOException(errMessage("nc_put_vars", ret, grpid, varid));
  }

  @Override
  public int appendStructureData(Structure s, StructureData sdata) throws IOException, InvalidRangeException {
    Vinfo vinfo = (Vinfo) s.getSPobject();
    Dimension dim = s.getDimension(0); // LOOK must be outer dim
    int dimid = vinfo.g4.dimHash.get(dim);
    SizeTByReference lenp = new SizeTByReference();
    int ret = nc4.nc_inq_dimlen(vinfo.g4.grpid, dimid, lenp);
    if (ret != 0)
      throw new IOException(errMessage("nc_inq_dimlen", ret, vinfo.g4.grpid, dimid));

    SizeT[] origin = {lenp.getValue()};
    SizeT[] shape = {new SizeT(1)};
    SizeT[] stride = {new SizeT(1)};

    // ArrayStructureBB valuesBB = IospHelper.copyToArrayBB(sdata, ByteOrder.nativeOrder());
    // n4 wants native byte order
    // ByteBuffer bbuff = valuesBB.getByteBuffer();
    ByteBuffer bbuff = makeBB(s, sdata);

    // write the data
    // ret = nc4.nc_put_vara(vinfo.g4.grpid, vinfo.varid, origin, shape, bbuff);
    // ret = nc4.nc_put_vars(vinfo.g4.grpid, vinfo.varid, origin, shape, stride, bbuff);
    ret = nc4.nc_put_vars(vinfo.g4.grpid, vinfo.varid, origin, shape, stride, bbuff.array());
    if (ret != 0)
      throw new IOException(errMessage("appendStructureData (nc_put_vars)", ret, vinfo.g4.grpid, vinfo.varid));

    return origin[0].intValue(); // recnum
  }

  private String errMessage(String what, int ret, int grpid, int varid) {
    Formatter f = new Formatter();
    f.format("%s: %d: %s grpid=%d objid=%d", what, ret, nc4.nc_strerror(ret), grpid, varid);
    return f.toString();
  }

  // copy data out of sdata into a ByteBuffer, based on the menmbers and offsets in s
  private ByteBuffer makeBB(Structure s, StructureData sdata) {
    int size = s.getElementSize();
    ByteBuffer bb = ByteBuffer.allocate(size);
    bb.order(ByteOrder.nativeOrder());

    long offset = 0;
    for (Variable v : s.getVariables()) {
      if (v.getDataType() == DataType.STRING)
        continue; // LOOK embedded strings getting lost

      StructureMembers.Member m = sdata.findMember(v.getShortName());
      if (m == null) {
        log.warn("WARN Nc4Iosp.makeBB() cant find {}", v.getShortName());
        bb.position((int) (offset + v.getElementSize() * v.getSize())); // skip over it
      } else {
        copy(sdata, m, bb);
      }

      offset += v.getElementSize() * v.getSize();
    }

    return bb;
  }

  private void copy(StructureData sdata, StructureMembers.Member m, ByteBuffer bb) {
    DataType dtype = m.getDataType();
    if (m.isScalar()) {
      switch (dtype) {
        case FLOAT:
          bb.putFloat(sdata.getScalarFloat(m));
          break;
        case DOUBLE:
          bb.putDouble(sdata.getScalarDouble(m));
          break;
        case INT:
        case ENUM4:
          bb.putInt(sdata.getScalarInt(m));
          break;
        case SHORT:
        case ENUM2:
          bb.putShort(sdata.getScalarShort(m));
          break;
        case BYTE:
        case ENUM1:
          bb.put(sdata.getScalarByte(m));
          break;
        case CHAR:
          bb.put((byte) sdata.getScalarChar(m));
          break;
        case LONG:
          bb.putLong(sdata.getScalarLong(m));
          break;
        default:
          throw new IllegalStateException("scalar " + dtype);
        /*
         * case BOOLEAN:
         * break;
         * case SEQUENCE:
         * break;
         * case STRUCTURE:
         * break;
         * case OPAQUE:
         * break;
         */
      }
    } else {
      int n = m.getSize();
      switch (dtype) {
        case FLOAT:
          float[] fdata = sdata.getJavaArrayFloat(m);
          for (int i = 0; i < n; i++)
            bb.putFloat(fdata[i]);
          break;
        case DOUBLE:
          double[] ddata = sdata.getJavaArrayDouble(m);
          for (int i = 0; i < n; i++)
            bb.putDouble(ddata[i]);
          break;
        case INT:
        case ENUM4:
          int[] idata = sdata.getJavaArrayInt(m);
          for (int i = 0; i < n; i++)
            bb.putInt(idata[i]);
          break;
        case SHORT:
        case ENUM2:
          short[] shdata = sdata.getJavaArrayShort(m);
          for (int i = 0; i < n; i++)
            bb.putShort(shdata[i]);
          break;
        case BYTE:
        case ENUM1:
          byte[] bdata = sdata.getJavaArrayByte(m);
          for (int i = 0; i < n; i++)
            bb.put(bdata[i]);
          break;
        case CHAR:
          char[] cdata = sdata.getJavaArrayChar(m);
          bb.put(IospHelper.convertCharToByte(cdata));
          break;
        case LONG:
          long[] ldata = sdata.getJavaArrayLong(m);
          for (int i = 0; i < n; i++)
            bb.putLong(ldata[i]);
          break;
        default:
          throw new IllegalStateException("array " + dtype);
        /*
         * case BOOLEAN:
         * break;
         * case OPAQUE:
         * break;
         * case STRUCTURE:
         * break; //
         */
        case SEQUENCE:
          break; // skip
      }
    }
  }

  private String[] convertStringData(Object org) throws IOException {
    if (org instanceof String[])
      return (String[]) org;
    if (org instanceof Object[]) {
      Object[] oo = (Object[]) org;
      String[] result = new String[oo.length];
      int count = 0;
      for (Object s : oo)
        result[count++] = (String) s;
      return result;
    }
    throw new IOException("convertStringData failed on class = " + org.getClass().getName());
  }

  /////////////////////////////////////////////////////////////////////////

  @Override
  public void flush() throws IOException {
    if (nc4 == null || ncid < 0)
      return; // not open yet

    int ret = nc4.nc_sync(ncid);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));

    // reread dimension in case unlimited has grown
    updateDimensions(ncfile.getRootGroup());
  }

  public Nc4Iosp setAddReserved(boolean tf) {
    this.markreserved = tf;
    return this;
  }

  @Override
  public void setFill(boolean fill) {
    this.fill = fill;
    try {
      _setFill();
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }

  private void _setFill() throws IOException {
    if (nc4 == null || ncid < 0)
      return; // not open yet

    IntByReference old_modep = new IntByReference();
    int ret = nc4.nc_set_fill(ncid, fill ? Nc4prototypes.NC_FILL : Nc4prototypes.NC_NOFILL, old_modep);
    if (ret != 0)
      throw new IOException(ret + ": " + nc4.nc_strerror(ret));
  }

  @Override
  public boolean rewriteHeader(boolean largeFile) throws IOException {
    // Rewriting just the header is not possible in NetCDF-4, so always return false.
    // This will cause NetcdfFileWriter.setRedefineMode(false) to rewrite the entire file instead.
    return false;
  }

  @Override
  public void updateAttribute(Variable v2, Attribute att) throws IOException {
    if (nc4 == null || ncid < 0)
      return; // not open yet

    if (v2 == null)
      writeAttribute(ncid, Nc4prototypes.NC_GLOBAL, att, null);
    else {
      Vinfo vinfo = (Vinfo) v2.getSPobject();
      writeAttribute(vinfo.g4.grpid, vinfo.varid, att, v2);
    }
  }

  public static long getNativeAddr(int pos, ByteBuffer buf) {
    return Platform.is64Bit() ? buf.getLong(pos) : buf.getInt(pos);
  }

  @Override
  public Object sendIospMessage(Object message) {
    if (message instanceof Map) {
      Map map = (Map) message;
      // See if we can extract some controls
      for (Object okey : map.keySet()) {
        String key = okey.toString();
        if (key.equalsIgnoreCase(TRANSLATECONTROL)) {
          String value = map.get(okey).toString();
          if (value.equalsIgnoreCase(TRANSLATE_NONE)) {
            this.markreserved = false;
          } else if (value.equalsIgnoreCase(TRANSLATE_NC4)) {
            this.markreserved = true;
          } // else ignore
        }
      }
    }
    if (message.equals(IOSP_MESSAGE_GET_NETCDF_FILE_FORMAT)) {
      return version;
    }
    return super.sendIospMessage(message);
  }

}