/// <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();
}
}
}
/// <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();
}
/// <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 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 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 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();
}
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);
}
