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