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)); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.Opaque) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.Compound)}"); } int fTagSize = (int)aHeader.Flags & byte.MaxValue; if (aLocalMessageSize.HasValue && aLocalMessageSize < fTagSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } aBytes = fTagSize; IEnumerable <MemberEntry> fMembers = null; return(new CompoundDataType( aHeader, fMembers)); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.FixedPoint) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.FixedPoint)}"); } 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; byte fLowPad = (byte)(fFlags.HasFlag(Flags.LowPad) ? 1 : 0), fHighPad = (byte)(fFlags.HasFlag(Flags.HighPad) ? 1 : 0); bool fIsSigned = fFlags.HasFlag(Flags.Signed); ushort fBitOffset = aReader.ReadUInt16(), fBitPrecision = aReader.ReadUInt16(); aBytes = mcAddionalSize; return(new FixedPointDataType( aHeader, fByteOrdering, fHighPad, fLowPad, fIsSigned, fBitOffset, fBitPrecision)); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.Opaque) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.Opaque)}"); } int fTagSize = (int)aHeader.Flags & byte.MaxValue; if (aLocalMessageSize.HasValue && aLocalMessageSize < fTagSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } byte[] fTagBytes = new byte[fTagSize]; int fReadByteCount = aReader.Read(fTagBytes, 0, fTagSize); if (fReadByteCount != fTagSize) { throw new EndOfStreamException("Could not read entire Opaque data type"); } String fAsciiTag = Encoding.ASCII.GetString(fTagBytes).TrimEnd((char)0); aBytes = fTagSize; return(new OpaqueDataType( aHeader, fAsciiTag)); }
internal static Datatype ReadMessage( DatatypeHeader aHeader, Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aHeader.Class != DatatypeClass.String) { throw new ArgumentException( $"aHeader must be for type {nameof(DatatypeClass.String)}"); } if (aLocalMessageSize.HasValue && aLocalMessageSize < 0) { throw new ArgumentException("Specified Local Message Size not long enough"); } byte fStringPadding = (byte)(aHeader.Flags & 0x0F), fStringEncoding = (byte)((aHeader.Flags & 0xF0) >> 4); if (fStringPadding > (byte)StringPadding.SpacePad) { throw new ArgumentException($"Invalid {nameof(StringPadding)}: {fStringPadding}"); } if (fStringEncoding > (byte)StringEncoding.UTF8) { throw new ArgumentException($"Invalid {nameof(StringEncoding)}: {fStringEncoding}"); } aBytes = 0;// No addional Read return(new StringDataType( aHeader, (StringPadding)fStringPadding, (StringEncoding)fStringEncoding)); }
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 Read( Hdf5Reader aReader, long?aLocalMessageSize, out long aBytes) { if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < DatatypeHeader.HeaderSize) { throw new ArgumentException("Specified Local Message Size not long enough"); } DatatypeHeader fHeader = DatatypeHeader.Read(aReader); Datatype fMessage; long fAdditionalBytes; long? fBodySize = aLocalMessageSize.HasValue ? (long?)aLocalMessageSize.Value - DatatypeHeader.HeaderSize : null; switch (fHeader.Class) { case DatatypeClass.FixedPoint: fMessage = FixedPointDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.FloatingPoint: fMessage = FloatingPointDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.Time: fMessage = TimeDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.String: fMessage = StringDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.BitField: fMessage = BitFieldDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.Opaque: fMessage = OpaqueDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; case DatatypeClass.Array: fMessage = ArrayDataType.ReadMessage( fHeader, aReader, fBodySize, out fAdditionalBytes); break; default: // We shoudl never git her, as header parsing should check // for known versions of the header throw new Exception("Unexpected Version Type"); } aBytes = DatatypeHeader.HeaderSize + fAdditionalBytes; return(fMessage); }
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)); }