docs: def storedata(self, fieldName, values, data_type, vName, vClass):
          """Create and initialize a single field vdata, returning
          the vdata reference number.
  
          Args::
  
            fieldName   Name of the single field in the vadata to create
            values      Sequence of values to store in the field;. Each value can
                        itself be a sequence, in which case the field will be
                        multivalued (all second-level sequences must be of
                        the same length)
            data_type   Values type (one of HC.xxx constants). All values
                        must be of the same type
            vName       Name of the vdata to create
            vClass      Vdata class (string)
  
  
          Returns::
  
            vdata reference number
  
          C library equivalent : VHstoredata / VHstoredatam
                                                  """
  
          # See if the field is multi-valued.
          nrecs = len(values)
          if type(values[0]) in [list, tuple]:
              order = len(values[0])
              # Replace input list with a flattened list.
              newValues = []
              for el in values:
                  for e in el:
                      newValues.append(e)
              values = newValues
          else:
              order = 1
          n_values = nrecs * order
          if data_type == HC.CHAR8:
              buf = _C.array_byte(n_values)
              # Allow values to be passed as a string.
              # Noop if a list is passed.
              values = list(values)
              for n in range(n_values):
                  values[n] = ord(values[n])
  
          elif data_type in [HC.UCHAR8, HC.UINT8]:
              buf = _C.array_byte(n_values)
  
          elif data_type == HC.INT8:
              # SWIG refuses negative values here. We found that if we
              # pass them as byte values, it will work.
              buf = _C.array_int8(n_values)
              values = list(values)
              for n in range(n_values):
                  v = values[n]
                  if v >= 0:
                      v &= 0x7f
                  else:
                      v = abs(v) & 0x7f
                      if v:
                          v = 256 - v
                      else:
                          v = 128         # -128 in 2s complement
                  values[n] = v
  
          elif data_type == HC.INT16:
              buf = _C.array_int16(n_values)
  
          elif data_type == HC.UINT16:
              buf = _C.array_uint16(n_values)
  
          elif data_type == HC.INT32:
              buf = _C.array_int32(n_values)
  
          elif data_type == HC.UINT32:
              buf = _C.array_uint32(n_values)
  
          elif data_type == HC.FLOAT32:
              buf = _C.array_float32(n_values)
  
          elif data_type == HC.FLOAT64:
              buf = _C.array_float64(n_values)
  
          else:
              raise HDF4Error("storedata: illegal or unimplemented data_type")
  
          for n in range(n_values):
              buf[n] = values[n]
          if order == 1:
              vd = _C.VHstoredata(self._hdf_inst._id, fieldName, buf,
                                  nrecs, data_type, vName, vClass)
          else:
              vd = _C.VHstoredatam(self._hdf_inst._id, fieldName, buf,
                                  nrecs, data_type, vName, vClass, order)
  
          _checkErr('storedata', vd, 'cannot create vdata')
  
          return vd