public static Hdf5Dataset CreateDatasetAddToDatasets(
ReadonlyNamedItemList <Hdf5Dataset> _datasets,
Hdf5Identifier _fileId,
Hdf5Path _parentPath,
string _name,
Hdf5DataTypes _datatype,
int _numberOfDimensions,
List <Hdf5DimensionProperty> _properties,
Hdf5CompressionProperty _compressionProperty = null)
{
Hdf5Dataset dataset = CreateDataset(
_fileId,
_parentPath,
_name,
_datatype,
_numberOfDimensions,
_properties,
_compressionProperty);
if (dataset != null)
{
_datasets.Add(dataset);
}
return(dataset);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Hdf5Dataspace GetDataspace(Hdf5Identifier _datasetId)
{
var dataspaceId = H5D.get_space(_datasetId.Value).ToId();
int rank = H5S.get_simple_extent_ndims(dataspaceId.Value);
ulong[] dims = new ulong[rank];
ulong[] maxDims = new ulong[rank];
H5S.get_simple_extent_dims(dataspaceId.Value, dims, maxDims);
Hdf5Dataspace dataspace = new Hdf5Dataspace
{
Id = dataspaceId,
NumberOfDimensions = rank
};
for (int i = 0; i < dims.Length; i++)
{
Hdf5DimensionProperty property = new Hdf5DimensionProperty
{
CurrentSize = dims[i],
//MaximumSize = maxDims[i]
};
dataspace.DimensionProperties.Add(property);
}
H5S.close(dataspaceId.Value);
return(dataspace);
}
/// <summary>
///
/// </summary>
/// <param name="_objectId"></param>
/// <param name="_attribute"></param>
public static void UpdateAttribute(Hdf5Identifier _objectId, Hdf5Attribute _attribute)
{
Hdf5Identifier attributeId = H5A.open(_objectId.Value, _attribute.Name).ToId();
if (attributeId.Value > 0)
{
Hdf5DataType type = TypeHelper.GetDataTypeFromAttribute(attributeId);
Hdf5DataTypes enumType = TypeHelper.GetDataTypesEnum(_attribute.Value.GetType());
if (type.Type == enumType)
{
if (enumType == Hdf5DataTypes.String)
{
H5A.close(attributeId.Value);
DeleteAttribute(_objectId, _attribute.Name);
Hdf5Attribute attribute = CreateAttribute(_objectId, _attribute.Name, _attribute.Value);
if (attribute != null)
{
_attribute.Id = attribute.Id;
_attribute.Name = attribute.Name;
_attribute.Value = attribute.Value;
}
}
else
{
WriteObjectValue(type, attributeId, _attribute.Value);
}
}
else
{
throw new Hdf5TypeMismatchException();
}
}
}
public static object GetObject(Hdf5Identifier _fileId, AbstractHdf5Object _parent, string _objectName)
{
Hdf5Path combinedPath = _parent.Path.Append(_objectName);
object output = null;
if (combinedPath != null)
{
string fullPath = combinedPath.FullPath;
H5O.info_t gInfo = new H5O.info_t();
H5O.get_info_by_name(_fileId.Value, fullPath, ref gInfo);
var id = H5O.open(_fileId.Value, fullPath).ToId();
if (id.Value > 0)
{
if (gInfo.type == H5O.type_t.DATASET)
{
output = DatasetHelper.LoadDataset(_fileId, id, fullPath);
}
if (gInfo.type == H5O.type_t.GROUP)
{
Hdf5Group group = new Hdf5Group(_fileId, id, fullPath);
group.FileId = _fileId;
group.LoadChildObjects();
output = group;
}
H5O.close(id.Value);
}
}
return(output);
}
public static Hdf5Identifier ToId(this Int32 value)
#endif
{
var id = new Hdf5Identifier(value);
return(id);
}
public static Hdf5Identifier ToId(this long _value)
#endif
{
var id = new Hdf5Identifier(_value);
return(id);
}
public static Hdf5Dataset CreateDataset(
Hdf5Identifier _fileId,
Hdf5Path _parentPath,
string _name,
Hdf5DataTypes _datatype,
int _numberOfDimensions,
List <Hdf5DimensionProperty> _properties)
{
Hdf5Path path = _parentPath.Append(_name);
UInt64[] dimensionSize = new UInt64[_numberOfDimensions];
UInt64[] maxSize = null; // new UInt64[_numberOfDimensions];
int i = 0;
foreach (var property in _properties)
{
dimensionSize[i] = property.CurrentSize;
//if (property.MaximumSize == UInt64.MaxValue)
//{
// maxSize[i] = H5S.UNLIMITED;
//}
//else
//{
// maxSize[i] = property.MaximumSize;
//}
i++;
}
Hdf5Identifier dataspaceId = H5S.create_simple(_numberOfDimensions, dimensionSize, maxSize).ToId();
//TODO handle string datasets
Hdf5Identifier typeId = H5T.copy(TypeHelper.GetNativeType(_datatype).Value).ToId();
var status = H5T.set_order(typeId.Value, H5T.order_t.LE);
Hdf5Identifier datasetId = H5D.create(_fileId.Value, path.FullPath, typeId.Value, dataspaceId.Value).ToId();
Hdf5Dataset dataset = null;
if (datasetId.Value > 0)
{
dataset = new Hdf5Dataset(_fileId, datasetId, path.FullPath)
{
DataType = TypeHelper.GetDataTypeFromDataset(datasetId),
Dataspace = DataspaceHelper.GetDataspace(datasetId)
};
H5D.close(datasetId.Value);
}
H5T.close(typeId.Value);
FileHelper.FlushToFile(_fileId);
return(dataset);
}
/// <summary>
/// Routes to generic read method based on correct data type
/// </summary>
/// <param name="_dataType"></param>
/// <param name="_attributeId"></param>
/// <returns></returns>
public static Object ReadValue(
Hdf5DataType _dataType,
Hdf5Identifier _attributeId)
{
if (_dataType.Type == Hdf5DataTypes.Int8)
{
return(ReadValue <sbyte>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.Int16)
{
return(ReadValue <Int16>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.Int32)
{
return(ReadValue <Int32>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.Int64)
{
return(ReadValue <Int64>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.UInt8)
{
return(ReadValue <byte>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.UInt16)
{
return(ReadValue <UInt16>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.UInt32)
{
return(ReadValue <UInt32>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.UInt64)
{
return(ReadValue <UInt64>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.Single)
{
return(ReadValue <Single>(_dataType, _attributeId));
}
if (_dataType.Type == Hdf5DataTypes.Double)
{
return(ReadValue <Double>(_dataType, _attributeId));
}
throw new Hdf5UnknownDataType();
}
public static void PopulateChildrenObjects <T>(Hdf5Identifier _fileId, T _parentObject) where T : AbstractHdf5Object
{
ulong pos = 0;
List <string> groupNames = new List <string>();
var id = H5G.open(_fileId.Value, _parentObject.Path.FullPath).ToId();
if (id.Value > 0)
{
ArrayList al = new ArrayList();
GCHandle hnd = GCHandle.Alloc(al);
IntPtr op_data = (IntPtr)hnd;
H5L.iterate(_parentObject.Id.Value, H5.index_t.NAME, H5.iter_order_t.NATIVE, ref pos,
delegate(int _objectId, IntPtr _namePtr, ref H5L.info_t _info, IntPtr _data)
{
string objectName = Marshal.PtrToStringAnsi(_namePtr);
groupNames.Add(objectName);
return(0);
}, op_data);
hnd.Free();
H5G.close(id.Value);
foreach (var groupName in groupNames)
{
Object hdf5Obj = GetObject(_fileId, _parentObject, groupName);
if (hdf5Obj != null)
{
if (hdf5Obj is Hdf5Dataset)
{
var parent = _parentObject as IHasDatasets;
if (parent != null)
{
parent.Datasets.Add(hdf5Obj as Hdf5Dataset);
}
}
else if (hdf5Obj is Hdf5Group)
{
var parent = _parentObject as IHasGroups;
if (parent != null)
{
parent.Groups.Add(hdf5Obj as Hdf5Group);
}
}
}
}
}
}
public static Hdf5DataType GetDataTypeFromAttribute(Hdf5Identifier _objectId)
{
var typeId = H5A.get_type(_objectId.Value).ToId();
if (typeId.Value > 0)
{
return(GetDataTypeByType(typeId));
}
return(null);
}
private static Array SingleDimension(Hdf5Identifier _datasetIdentifer, Hdf5Dataset _dataset)
{
if (_dataset.DataType.Type == Hdf5DataTypes.Int8)
{
return(Read1DArray <sbyte>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.Int16)
{
return(Read1DArray <Int16>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.Int32)
{
return(Read1DArray <Int32>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.Int64)
{
return(Read1DArray <Int64>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.UInt8)
{
return(Read1DArray <byte>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.UInt16)
{
return(Read1DArray <UInt16>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.UInt32)
{
return(Read1DArray <UInt32>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.UInt64)
{
return(Read1DArray <UInt64>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.Single)
{
return(Read1DArray <Single>(_datasetIdentifer, _dataset));
}
if (_dataset.DataType.Type == Hdf5DataTypes.Double)
{
return(Read1DArray <Double>(_datasetIdentifer, _dataset));
}
return(null);
}
internal Hdf5Dataset(Hdf5Identifier _fileId, Hdf5Identifier _id, string _path)
{
FileId = _fileId;
Id = _id;
Path = new Hdf5Path(_path);
Name = Path.Name;
m_Attributes = new Hdf5Attributes(this);
AttributeHelper.LoadAttributes(m_Attributes);
}
/// <summary>
/// Assumes that dataset already open
/// </summary>
/// <param name="_fileId"></param>
/// <param name="_datasetId"></param>
/// <param name="_fullPath"></param>
/// <returns></returns>
public static Hdf5Dataset LoadDataset(Hdf5Identifier _fileId, Hdf5Identifier _datasetId, string _fullPath)
{
Hdf5DataType datatype = TypeHelper.GetDataTypeFromDataset(_datasetId);
Hdf5Dataspace dataspace = DataspaceHelper.GetDataspace(_datasetId);
Hdf5Dataset dataset = new Hdf5Dataset(_fileId, _datasetId, _fullPath)
{
Dataspace = dataspace,
DataType = datatype
};
return(dataset);
}
/// <summary>
/// Reads a non-string attribute
/// Assumes the parent object is already open
/// </summary>
/// <param name="_attributeId"></param>
/// <param name="_title"></param>
/// <param name="_type"></param>
/// <returns></returns>
public static Hdf5Attribute GetAttribute(Hdf5Identifier _attributeId, string _title, Hdf5DataType _type)
{
Object value = ReadValue(_type, _attributeId);
var attribute = new Hdf5Attribute
{
Id = _attributeId,
Name = _title,
Value = value
};
return(attribute);
}
public static Hdf5Group CreateGroupAddToList(
ReadonlyNamedItemList <Hdf5Group> _groups,
Hdf5Identifier _fileId,
Hdf5Path _parentPath,
string _name)
{
Hdf5Group group = CreateGroup(_fileId, _parentPath, _name);
if (group != null)
{
_groups.Add(group);
}
return(group);
}
public static Hdf5Group CreateGroup(Hdf5Identifier _fileId, Hdf5Path _parentPath, string _name)
{
Hdf5Path path = _parentPath.Append(_name);
var id = H5G.create(_fileId.Value, path.FullPath);
if (id > 0)
{
Hdf5Group group = new Hdf5Group(_fileId, id.ToId(), path.FullPath);
H5G.close(id);
FileHelper.FlushToFile(_fileId);
return(group);
}
return(null);
}
/// <summary>
/// Creates the attribute then adds to the supplied attribute list.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_objectId"></param>
/// <param name="_attributes"></param>
/// <param name="_title"></param>
/// <param name="_value"></param>
/// <returns></returns>
public static Hdf5Attribute CreateAttributeAddToList <T>(
Hdf5Identifier _objectId,
ReadonlyNamedItemList <Hdf5Attribute> _attributes,
string _title,
T _value)
{
Hdf5Attribute attribute = CreateAttribute(_objectId, _title, _value);
if (attribute != null)
{
_attributes.Add(attribute);
}
return(attribute);
}
public static Hdf5File Create(string _filename)
{
if (File.Exists(_filename))
{
throw new Hdf5FileExistsException();
}
Hdf5Identifier fileId = H5F.create(_filename, H5F.ACC_EXCL).ToId();
if (fileId.Value > 0)
{
H5F.close(fileId.Value);
return(new Hdf5File(_filename));
}
throw new Hdf5UnknownException();
}
internal Hdf5Group(
Hdf5Identifier _fileId,
Hdf5Identifier _groupId,
string _path)
{
FileId = _fileId;
Id = _groupId;
Path = new Hdf5Path(_path);
Name = Path.Name;
Groups = new Hdf5Groups(this);
Datasets = new Hdf5Datasets(this);
Attributes = new Hdf5Attributes(this);
AttributeHelper.LoadAttributes(Attributes);
}
/// <summary>
/// Reads from the hdf file
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_dataType"></param>
/// <param name="_attributeId"></param>
/// <returns></returns>
private static T ReadValue <T>(
Hdf5DataType _dataType,
Hdf5Identifier _attributeId)
{
T[] value = new T[1];
GCHandle arrayHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
var dataType = H5T.copy(_dataType.NativeType.Value).ToId();
int result = H5A.read(_attributeId.Value, dataType.Value, arrayHandle.AddrOfPinnedObject());
arrayHandle.Free();
H5T.close(dataType.Value);
return(value[0]);
}
/// <summary>
/// Writes the specified value to the file
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_dataType"></param>
/// <param name="_attributeId"></param>
/// <param name="_value"></param>
private static void WriteValue <T>(
Hdf5DataType _dataType,
Hdf5Identifier _attributeId,
T _value)
{
T[] value = new T[1];
value[0] = _value;
GCHandle arrayHandle = GCHandle.Alloc(value, GCHandleType.Pinned);
var dataType = H5T.copy(_dataType.NativeType.Value).ToId();
int result = H5A.write(_attributeId.Value, dataType.Value, arrayHandle.AddrOfPinnedObject());
arrayHandle.Free();
H5T.close(dataType.Value);
}
/// <summary>
/// Reads a string scalar attribute value.
/// Assumes that the parent object is already open.
/// </summary>
/// <param name="_objectId"></param>
/// <param name="_title"></param>
/// <returns></returns>
public static Hdf5Attribute GetStringAttribute(Hdf5Identifier _objectId, string _title)
{
int attributeId = 0;
int typeId = 0;
attributeId = H5A.open(_objectId.Value, _title);
typeId = H5A.get_type(attributeId);
var sizeData = H5T.get_size(typeId);
var size = sizeData.ToInt32();
byte[] strBuffer = new byte[size];
var aTypeMem = H5T.get_native_type(typeId, H5T.direction_t.ASCEND);
GCHandle pinnedArray = GCHandle.Alloc(strBuffer, GCHandleType.Pinned);
H5A.read(attributeId, aTypeMem, pinnedArray.AddrOfPinnedObject());
pinnedArray.Free();
H5T.close(aTypeMem);
string value = System.Text.Encoding.ASCII.GetString(strBuffer, 0, strBuffer.Length - 1);
var attribute = new Hdf5Attribute
{
Id = attributeId.ToId(),
Name = _title,
Value = value
};
if (attributeId > 0)
{
H5A.close(attributeId);
}
if (typeId > 0)
{
H5T.close(typeId);
}
return(attribute);
}
/// <summary>
/// Assumes dataset is already open
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_datasetIdentifer"></param>
/// <param name="_dataset"></param>
/// <returns></returns>
public static T[] Read1DArray <T>(Hdf5Identifier _datasetIdentifer, Hdf5Dataset _dataset)
{
T[] dataArray = new T[_dataset.Dataspace.DimensionProperties[0].CurrentSize];
GCHandle arrayHandle = GCHandle.Alloc(dataArray, GCHandleType.Pinned);
var dataType = H5T.copy(_dataset.DataType.NativeType.Value).ToId();
int result = H5D.read(
_datasetIdentifer.Value,
dataType.Value,
H5S.ALL,
H5S.ALL,
H5P.DEFAULT,
arrayHandle.AddrOfPinnedObject());
arrayHandle.Free();
H5T.close(dataType.Value);
return(dataArray);
}
public static Hdf5Dataset CreateDataset(
Hdf5Identifier _fileId,
Hdf5Path _parentPath,
string _name,
Hdf5DataTypes _datatype,
int _numberOfDimensions,
List <Hdf5DimensionProperty> _properties,
Hdf5CompressionProperty _compressionProperty = null)
{
Hdf5Path path = _parentPath.Append(_name);
UInt64[] dimensionSize = new UInt64[_numberOfDimensions];
UInt64[] maxSize = null; // new UInt64[_numberOfDimensions];
if (_numberOfDimensions != _properties.Count ||
(_compressionProperty != null && _numberOfDimensions != _compressionProperty.ChunkDimensions.Length))
{
throw new Hdf5ArrayDimensionsMismatchException();
}
int i = 0;
foreach (var property in _properties)
{
dimensionSize[i] = property.CurrentSize;
if (_compressionProperty != null && _compressionProperty.ChunkDimensions[i] > property.CurrentSize)
{
throw new Hdf5ArraySizeMismatchException();
}
i++;
}
Hdf5Identifier dataspaceId = H5S.create_simple(_numberOfDimensions, dimensionSize, maxSize).ToId();
//TODO handle string datasets
Hdf5Identifier typeId = H5T.copy(TypeHelper.GetNativeType(_datatype).Value).ToId();
var status = H5T.set_order(typeId.Value, H5T.order_t.LE);
var plist_id = _compressionProperty != null?H5P.create(H5P.DATASET_CREATE) : 0;
if (plist_id != 0)
{
H5P.set_chunk(plist_id, _compressionProperty.ChunkDimensions.Length, _compressionProperty.ChunkDimensions);
H5P.set_deflate(plist_id, _compressionProperty.CompressionLevel);
}
Hdf5Identifier datasetId = H5D.create(_fileId.Value, path.FullPath, typeId.Value, dataspaceId.Value, dcpl_id: plist_id).ToId();
Hdf5Dataset dataset = null;
if (datasetId.Value > 0)
{
dataset = new Hdf5Dataset(_fileId, datasetId, path.FullPath)
{
DataType = TypeHelper.GetDataTypeFromDataset(datasetId),
Dataspace = DataspaceHelper.GetDataspace(datasetId)
};
H5D.close(datasetId.Value);
}
H5T.close(typeId.Value);
if (plist_id != 0)
{
H5P.close(plist_id);
}
FileHelper.FlushToFile(_fileId);
return(dataset);
}
public static Hdf5DataType GetDataTypeByType(Hdf5Identifier _typeId)
{
var typeClass = H5T.get_class(_typeId.Value);
var typeSize = (int)H5T.get_size(_typeId.Value);
var typeSign = H5T.get_sign(_typeId.Value);
var typeOrder = H5T.get_order(_typeId.Value);
Hdf5DataType dt = new Hdf5DataType
{
Id = _typeId,
Size = typeSize,
};
if (typeOrder == H5T.order_t.BE)
{
dt.ByteOrder = Hdf5ByteOrder.BigEndian;
}
else if (typeOrder == H5T.order_t.LE)
{
dt.ByteOrder = Hdf5ByteOrder.LittleEndian;
}
else if (typeOrder == H5T.order_t.ONE)
{
dt.ByteOrder = Hdf5ByteOrder.None;
}
if (typeClass == H5T.class_t.INTEGER)
{
if (typeSign == H5T.sign_t.NONE)
{
if (typeSize == 1)
{
dt.Type = Hdf5DataTypes.UInt8;
dt.NativeType = H5T.NATIVE_UINT8.ToId();
}
else if (typeSize == 2)
{
dt.Type = Hdf5DataTypes.UInt16;
dt.NativeType = H5T.NATIVE_UINT16.ToId();
}
else if (typeSize == 4)
{
dt.Type = Hdf5DataTypes.UInt32;
dt.NativeType = H5T.NATIVE_UINT32.ToId();
}
else if (typeSize == 8)
{
dt.Type = Hdf5DataTypes.UInt64;
dt.NativeType = H5T.NATIVE_UINT64.ToId();
}
}
else
{
if (typeSize == 1)
{
dt.Type = Hdf5DataTypes.Int8;
dt.NativeType = H5T.NATIVE_INT8.ToId();
}
else if (typeSize == 2)
{
dt.Type = Hdf5DataTypes.Int16;
dt.NativeType = H5T.NATIVE_INT16.ToId();
}
else if (typeSize == 4)
{
dt.Type = Hdf5DataTypes.Int32;
dt.NativeType = H5T.NATIVE_INT32.ToId();
}
else if (typeSize == 8)
{
dt.Type = Hdf5DataTypes.Int64;
dt.NativeType = H5T.NATIVE_INT64.ToId();
}
}
}
else if (typeClass == H5T.class_t.FLOAT)
{
if (typeSize == 4)
{
dt.Type = Hdf5DataTypes.Single;
dt.NativeType = H5T.NATIVE_FLOAT.ToId();
}
else if (typeSize == 8)
{
dt.Type = Hdf5DataTypes.Double;
dt.NativeType = H5T.NATIVE_DOUBLE.ToId();
}
}
else if (typeClass == H5T.class_t.STRING)
{
dt.Type = Hdf5DataTypes.String;
dt.NativeType = H5T.C_S1.ToId();
}
return(dt);
}
public static void FlushToFile(Hdf5Identifier _fileId)
{
H5F.flush(_fileId.Value, H5F.scope_t.GLOBAL);
}
/// <summary>
/// Deletes the attribute from the file.
/// Assumes that parent object is already open
/// </summary>
/// <param name="_objectId"></param>
/// <param name="_title"></param>
public static void DeleteAttribute(Hdf5Identifier _objectId, string _title)
{
int result = H5A.delete(_objectId.Value, _title);
}
public static void WriteObjectValue(
Hdf5DataType _dataType,
Hdf5Identifier _attributeId,
object _value)
{
if (_dataType.Type == Hdf5DataTypes.Int8)
{
WriteValue(_dataType, _attributeId, (sbyte)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.Int16)
{
WriteValue(_dataType, _attributeId, (Int16)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.Int32)
{
WriteValue(_dataType, _attributeId, (Int32)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.Int64)
{
WriteValue(_dataType, _attributeId, (Int64)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.UInt8)
{
WriteValue(_dataType, _attributeId, (byte)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.UInt16)
{
WriteValue(_dataType, _attributeId, (UInt16)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.UInt32)
{
WriteValue(_dataType, _attributeId, (UInt32)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.UInt64)
{
WriteValue(_dataType, _attributeId, (UInt64)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.Single)
{
WriteValue(_dataType, _attributeId, (Single)_value);
return;
}
if (_dataType.Type == Hdf5DataTypes.Double)
{
WriteValue(_dataType, _attributeId, (Double)_value);
return;
}
throw new Hdf5UnknownDataType();
}
/// <summary>
/// Currently does not support arrays
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="_objectId"></param>
/// <param name="_title"></param>
/// <param name="_value"></param>
/// <returns></returns>
public static Hdf5Attribute CreateAttribute <T>(Hdf5Identifier _objectId, string _title, T _value)
{
ulong[] sizes = new ulong[1] {
1
};
Hdf5Identifier dataspaceId;
Hdf5Identifier attributeId;
Hdf5Identifier typeId;
Hdf5Attribute attribute = null;
Type type = _value.GetType();
var datatype = TypeHelper.GetDataTypesEnum(type);
if (datatype != Hdf5DataTypes.String)
{
var tempType = TypeHelper.GetNativeType(datatype);
typeId = H5T.copy(tempType.Value).ToId();
var dataTypeObject = TypeHelper.GetDataTypeByType(typeId);
var status = H5T.set_order(typeId.Value, H5T.order_t.LE);
dataspaceId = H5S.create_simple(1, sizes, null).ToId();
attributeId = H5A.create(_objectId.Value, _title, typeId.Value, dataspaceId.Value).ToId();
if (attributeId.Value > 0)
{
WriteValue(dataTypeObject, attributeId, _value);
}
}
else
{
string tempValue = Convert.ToString(_value);
dataspaceId = H5S.create(H5S.class_t.SCALAR).ToId();
typeId = H5T.copy(H5T.C_S1).ToId();
int length = tempValue.Length + 1;
var result = H5T.set_size(typeId.Value, new IntPtr(length));
attributeId = H5A.create(_objectId.Value, _title, typeId.Value, dataspaceId.Value).ToId();
IntPtr valueArray = Marshal.StringToHGlobalAnsi(tempValue);
result = H5A.write(attributeId.Value, typeId.Value, valueArray);
Marshal.FreeHGlobal(valueArray);
}
H5S.close(dataspaceId.Value);
H5T.close(typeId.Value);
H5A.close(attributeId.Value);
if (attributeId.Value > 0)
{
attribute = new Hdf5Attribute
{
Value = _value,
Name = _title,
Id = attributeId
};
}
return(attribute);
}
