/// <summary>
/// Read the specified aStream and aLocation.
/// </summary>
/// <returns>The read.</returns>
/// <param name="aStream">A stream.</param>
/// <param name="aLocation">A location.</param>
public static SymbolTableEntry Read(
Hdf5Reader aReader)
{
Offset fLinkNameOffset = aReader.ReadOffset();
Offset fObjectHeaderAddress = aReader.ReadOffset();
CacheType fCacheType = (CacheType)aReader.ReadUInt32();
aReader.ReadUInt32(); // Reserved Word
switch (fCacheType)
{
case CacheType.NoCache:
return(new SymbolTableEntry(
fLinkNameOffset,
fObjectHeaderAddress));
case CacheType.Cache:
return(new SymbolTableEntry(
fLinkNameOffset,
fObjectHeaderAddress,
aReader.ReadOffset(),
aReader.ReadOffset()));
case CacheType.SymbolicLink:
return(new SymbolTableEntry(
fLinkNameOffset,
fObjectHeaderAddress,
aReader.ReadUInt32()));
default:
throw new InvalidDataException($"Unknown {nameof(CacheType)}");
}
}
internal static Datatype ReadMessage(
DatatypeHeader aHeader,
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
if (aHeader.Class != DatatypeClass.Time)
{
throw new ArgumentException(
$"aHeader must be for type {nameof(DatatypeClass.Time)}");
}
if (aLocalMessageSize.HasValue && aLocalMessageSize < mcAddionalSize)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
Flags fFlags = (Flags)aHeader.Flags;
ByteOrdering
fByteOrdering = fFlags.HasFlag(Flags.BigEndian)
? ByteOrdering.BigEndian
: ByteOrdering.LittleEndian;
uint
fBitPrecision = aReader.ReadUInt32();
aBytes = mcAddionalSize;
return(new TimeDataType(
aHeader,
fByteOrdering,
fBitPrecision));
}
public static IObjectHeader Read(byte[] aHeadBytes, Hdf5Reader aReader)
{
List <Message>
fMessages = new List <Message>();
ushort
fMessageCount = (ushort)(aHeadBytes[2] + (aHeadBytes[3] << 8)); //Little endian read of already consumed data
uint
fObjectReferenceCount = aReader.ReadUInt32(),
fObjectHeaderSize = aReader.ReadUInt32();
//long
// fTerminate = aReader.Position + fObjectHeaderSize;
//while(aReader.Position <= fTerminate)
//{
//}
throw new NotImplementedException();
}
public static Version1 ReadAfterHeader(
DSHeader aHeader,
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
int
fDimCount = aHeader.Dimensionality,
fBlockLength = (fDimCount * aReader.SuperBlock.SizeOfLengths);
long
fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths) + sizeof(UInt32);
Flags
fHeaderFlags = (Flags)aHeader.Flags;
if (fHeaderFlags.HasFlag(Flags.HasPermutaions))
{
throw new NotSupportedException("Permutation index not supported");
}
bool
fHasMax = fHeaderFlags.HasFlag(Flags.HasMax);
if (fHasMax)
{
fReadlength += fBlockLength;
}
if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
aReader.ReadUInt32(); //Read reserved byte
aBytes = fReadlength;
Dimension[] fDimensions = ReadDimensions(
aReader,
fHasMax,
fDimCount);
return(new Version1(DataSpaceType.Simple, fDimensions));
}
public static DatatypeHeader Read(Hdf5Reader aStream)
{
byte[]
fBuffer = new byte[HeaderSize];
if (4 != aStream.Read(fBuffer, 0, 4))
{
throw new EndOfStreamException();
}
byte
fVersion = (byte)((fBuffer[0] >> 4) & 0xF);
if (fVersion < (byte)DatatypeVersion.Version1 || fVersion > (byte)DatatypeVersion.Version3)
{
throw new UnknownMessageVersion <Datatype>(fVersion);
}
byte
fClass = (byte)(fBuffer[0] & 0xF);
if (fClass > (byte)DatatypeClass.Array)
{
throw new InvalidDataException($"Unkown Datatype Class {fClass}");
}
uint
fFlags = (uint)(fBuffer[1] |
fBuffer[2] << 8 |
fBuffer[3] << 16);
uint
fSize = aStream.ReadUInt32();
return(new DatatypeHeader(
(DatatypeVersion)fVersion,
(DatatypeClass)fClass,
fFlags,
fSize));
}
private ISuperBlock ParseV2orV3(SuperBlockObj aContainer, bool aIsV3)
{
using (Stream fStream = mrStreamProvider.GetReadonlyStream())
{
fStream.Seek(
(long)(ulong)(aContainer.LocationAddress + FormatSignatureAndVersionInfo.Length),
SeekOrigin.Begin);
const byte
fcHeaderBytes = 3;
byte[]
fHeadbuffer = new byte[fcHeaderBytes];
if (fcHeaderBytes != fStream.Read(fHeadbuffer, 0, fcHeaderBytes))
{
throw new EndOfStreamException("Could not read Superblock");
}
aContainer.SizeOfOffsets = fHeadbuffer[0];
aContainer.SizeOfLengths = fHeadbuffer[1];
byte
fFlags = fHeadbuffer[2];
if ((fFlags & ~((int)(FileConsistencyFlags.SwmrAccessEngaged | FileConsistencyFlags.WriteAccessOpen))) != 0)
{
throw new InvalidDataException($"Unexpected {nameof(FileConsistencyFlags)}: 0x{fFlags:X}");
}
if (aIsV3)
{
aContainer.FileConsistencyFlags = (FileConsistencyFlags)fFlags;
}
int
fFieldByteCount = aContainer.SizeOfOffsets * 4 + 4;
byte[]
fFieldBytes = new byte[fFieldByteCount];
fStream.Read(fFieldBytes, 0, fFieldByteCount);
using (MemoryStream fMemoryStream = new MemoryStream(fFieldBytes))
using (Hdf5Reader fReader = new Hdf5Reader(fMemoryStream, aContainer, false))
{
Offset
fBaseAddress = fReader.ReadOffset(),
fSuperBlockExtensionAddress = fReader.ReadOffset(),
fEndOfFileAddress = fReader.ReadOffset(),
fRootGroupAddress = fReader.ReadOffset();
if (fBaseAddress.IsNull())
{
throw new InvalidDataException("No base adddress Specified");
}
aContainer.BaseAddress = fBaseAddress;
//TODO: Handle SuperVlock Extensions
if (fEndOfFileAddress.IsNull())
{
throw new InvalidDataException("No End Of file Adddress Specified");
}
aContainer.EndOfFileAddress = fEndOfFileAddress;
if (fRootGroupAddress.IsNull())
{
throw new InvalidDataException("No Root Group Specified");
}
aContainer.RootGroupAddress = fRootGroupAddress;
uint fExpectedCheckSum = Checksums.Lookup3.ComputeHash(
mrFormatSignatureAndVersionInfo.AsBytes
.Concat(fHeadbuffer)
.Concat(fFieldBytes.Take(fFieldByteCount - 4))
.ToArray());
if (fExpectedCheckSum != fReader.ReadUInt32())
{
throw new InvalidDataException("Bad Checksum");
}
}
}
return(aContainer);
}
internal static Datatype ReadMessage(
DatatypeHeader aHeader,
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
if (aHeader.Class != DatatypeClass.Array)
{
throw new ArgumentException(
$"aHeader must be for type {nameof(DatatypeClass.Array)}");
}
bool
fReadPermutaions;
long
fSize = sizeof(uint);
switch (aHeader.Version)
{
case DatatypeVersion.Version1:
throw new UnknownMessageVersion <ArrayDataType>(
(int)aHeader.Version,
"Arrays are not supported in verion 1");
case DatatypeVersion.Version2:
fReadPermutaions = true;
break;
default:
fReadPermutaions = false;
break;
}
byte
fDimensionality = aReader.ReadByte();
aReader.Seek(3, System.IO.SeekOrigin.Current); // Reserved bytes
uint[]
fDimeensions = Enumerable
.Range(0, fDimensionality)
.Select(a => aReader.ReadUInt32())
.ToArray();
fSize += fDimensionality * sizeof(uint);
if (fReadPermutaions)
{
if (!Enumerable.Range(0, fDimeensions.Length).All(a => a == aReader.ReadUInt32()))
{
throw new Hdf5UnsupportedFeature("Custom permutations not supported");
}
fSize += fDimensionality * sizeof(uint);
}
long?
fBaseLocalmessageSize = aLocalMessageSize;
if (fBaseLocalmessageSize.HasValue)
{
fBaseLocalmessageSize -= fSize;
}
long
fBaseTypeSize;
Datatype
fBaseType = Datatype.Read(aReader, fBaseLocalmessageSize, out fBaseTypeSize);
aBytes = fSize + fBaseTypeSize;
return(new ArrayDataType(aHeader, fDimeensions, fBaseType));
}
internal static Datatype ReadMessage(
DatatypeHeader aHeader,
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
if (aHeader.Class != DatatypeClass.FloatingPoint)
{
throw new ArgumentException(
$"aHeader must be for type {nameof(DatatypeClass.FloatingPoint)}");
}
if (aLocalMessageSize.HasValue && aLocalMessageSize < mcAddionalSize)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
Flags fFlags = (Flags)aHeader.Flags;
ByteOrdering
fByteOrdering;
Flags
fByteOrderFlags = Flags.ByteOrderMask & fFlags;
switch (fByteOrderFlags)
{
case Flags.None:
fByteOrdering = ByteOrdering.LittleEndian;
break;
case Flags.ByteOrderLow:
fByteOrdering = ByteOrdering.BigEndian;
break;
case Flags.ByteOrderMask:
fByteOrdering = ByteOrdering.VAXOrder;
break;
default:
throw new System.IO.InvalidDataException("Unknown Byte Ordering");
}
byte
fLowPad = (byte)(fFlags.HasFlag(Flags.LowPad) ? 1 : 0),
fHighPad = (byte)(fFlags.HasFlag(Flags.HighPad) ? 1 : 0),
fInternalPad = (byte)(fFlags.HasFlag(Flags.InternalPad) ? 1 : 0);
MantissaNormalization
fMantissaNormalization;
byte
fMantissaNormFlags = (byte)((byte)(Flags.MantissaNormalizationMask & fFlags) >> 4);
if (fMantissaNormFlags > (byte)MantissaNormalization.MsbSetNotStorred)
{
throw new System.IO.InvalidDataException("Unknown Mantissa Normalization");
}
fMantissaNormalization = (MantissaNormalization)fMantissaNormFlags;
ushort
fSignLocation = (ushort)((0x00FF00 & aHeader.Flags) >> 8);
ushort
fBitOffset = aReader.ReadUInt16(),
fBitPrecision = aReader.ReadUInt16();
byte
fExponentLocation = aReader.ReadByte(),
fExponentSize = aReader.ReadByte(),
fMantissaLocation = aReader.ReadByte(),
fMantissaSize = aReader.ReadByte();
uint
fExponentBias = aReader.ReadUInt32();
aBytes = mcAddionalSize;
return(new FloatingPointDataType(
aHeader,
fByteOrdering,
fHighPad,
fLowPad,
fInternalPad,
fSignLocation,
fBitOffset,
fBitPrecision,
fExponentLocation,
fExponentSize,
fMantissaLocation,
fMantissaSize,
fExponentBias));
}