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));
}
public void TestBasicLengthedNilRead(
[Values] uMessages.MessageAttributeFlag aFlags,
[Values(2, 4, 8)] int aOffsetBytes,
[Values(2, 4, 8)] int aLengthBytes,
[Values(0, 2, 4, 8, 255, 2047)] int aReadBytes)
{
Mock <ndf5.Metadata.ISuperBlock>
fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose);
fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)aOffsetBytes);
fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)aLengthBytes);
Hdf5Reader
fReader = new Hdf5Reader(new System.IO.MemoryStream(new byte[0]), fSuperBlock.Object);
long fRead;
uMessages.Message fShortTest = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.NIL,
aFlags,
(long)aReadBytes,
out fRead);
Assert.That(fShortTest, Is.InstanceOf(typeof(uMessages.Nil)),
"Incorrect Message type parsed");
Assert.That(fRead, Is.EqualTo(0),
"Zero bytes should be read");
}
public void Test_SixteenBit_Example()
{
//Arrange
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write(new byte[] {
0x12, 0x00, 0x00, 0x00,
0x04, 0x00, 0x00, 0x00,
0x20, 0x00, 0x00, 0x00,
});
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
uTest fResult = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
null,
out fReadBytes) as uTest;
Assert.That(
fResult,
Is.Not.Null,
"Incorrect Message Type returned");
Assert.That(
fReadBytes,
Is.EqualTo(12),
"Wrong number of bytes read");
Assert.That(
fTestSource.Position,
Is.EqualTo(12),
"Wrong number of bytes read");
Assert.That(
fResult.Class,
Is.EqualTo(uMessages.DatatypeClass.Time),
"Incorrect Data class");
Assert.That(
fResult.ByteOrdering,
Is.EqualTo(ByteOrdering.LittleEndian),
"Incorrect byte ordering");
Assert.That(
fResult.Size,
Is.EqualTo(4),
"Incorrect Data Element Size");
Assert.That(
fResult.BitPrecision,
Is.EqualTo(32),
"Incorrect bit precision");
}
}
}
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));
}
/// <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)}");
}
}
public void Short_Read_Checking_Test(
[Range(0, 11)] int aNumBytesGiven)
{
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write(new byte[] {
0x10, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
});
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
Assert.That(() =>
{
ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
aNumBytesGiven,
out fReadBytes);
}, Throws.ArgumentException,
"Length not checked");
}
}
}
/// <summary>
/// Parse the specified SymbolTableEntry frome aStreamProvider and aLocation.
/// </summary>
/// <returns>The parsed SymbolTableEntry</returns>
/// <param name="aStreamProvider">A stream provider.</param>
/// <param name="aLocation">The location in the stream of the SymbolTableEntry</param>
public static SymbolTableEntry Parse(
IHdfStreamProvider aStreamProvider,
long aLocation)
{
using (Hdf5Reader aReader = aStreamProvider.GetReader())
{
return(Read(aReader));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="T:ndf5.Infrastructure.BTrees.V1.Node"/> class.
/// </summary>
/// <param name="aStreamProvider">A stream provider.</param>
/// <param name="aLocation">A location in the stream of this Node</param>
public static Node Parse(
IHdfStreamProvider aStreamProvider,
Offset aLocation)
{
using (Hdf5Reader fReader = aStreamProvider.GetReader())
{
return(new Node(fReader, aLocation));
}
}
public void Short_Stream_Check(
[Values] uMessages.DatatypeClass aDatatypeClass,
[Values] uMessages.DatatypeVersion aVersion)
{
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write((byte)(((byte)aVersion << 4) | ((byte)aDatatypeClass)));
fWriter.Write(new byte[] {
0x00, 0x00,
});
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
Assert.That(() =>
{
ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
12,
out fReadBytes);
}, Throws.Exception.TypeOf(typeof(System.IO.EndOfStreamException)),
"Length not checked");
//Add three more bytes to get past the header length
fWriter.Write(new byte[] {
0x10, 0x00, 0x00,
});
fTestSource.Seek(0, SeekOrigin.Begin);
Assert.That(() =>
{
ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
12,
out fReadBytes);
}, Throws.Exception.TypeOf(typeof(System.IO.EndOfStreamException)),
"Length not checked");
}
}
}
public static void Test_V1_Parse_Fail(
[Values(0, 1, 12, 37, 42)] int aLength)
{
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write((byte)(((byte)DatatypeVersion.Version1 << 4) | 0x0A));
fWriter.Write((byte)0);
fWriter.Write((byte)0);
fWriter.Write((byte)0);
fWriter.Write((byte)aLength);
fWriter.Write((byte)0);
fWriter.Write((byte)0);
fWriter.Write((byte)0);
System.Random
fRandom = new Random();
for (int fIndex = 0; fIndex < aLength; ++fIndex)
{
int fRnd = fRandom.Next();
fWriter.Write(fRnd);
}
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
Assert.That(() =>
{
uTest
fResult = ndf5.Messages.Message.Read(
fReader,
MessageType.Datatype,
MessageAttributeFlag.None,
null,
out fReadBytes) as uTest;
},
Throws.Exception,
"Version 1 should not parse");
}
}
}
internal static Message Read(
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
//Read Message Headder data
int
fReadBytes = 4; //Always Read at least 4
byte
fVersion = (byte)aReader.ReadByte(),
fFlags = (byte)aReader.ReadByte();
aReader.ReadUInt16(); //Reserved
if (fVersion != mcCurrentVersion)
{
throw new Exceptions.UnknownMessageVersion <LinkInfo>(fVersion);
}
bool
fCreationOrderTracked = ((Flags)fFlags).HasFlag(Flags.CreationOrderTracked),
fCreationOrderIndexed = ((Flags)fFlags).HasFlag(Flags.CreationOrderIndexed);
//Calculate Length
if (fCreationOrderTracked)
{
fReadBytes += 8;
}
fReadBytes += 2 * (int)aReader.SizeOfOffset; //Fractal Heap address, B-Tree adress
if (fCreationOrderIndexed)
{
fReadBytes += (int)aReader.SizeOfOffset;
}
aBytes = fReadBytes;
if (aLocalMessageSize.HasValue && fReadBytes > aLocalMessageSize.Value)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
//Read Feilds and build the object
LinkInfo
fToReturn = new LinkInfo(
fCreationOrderTracked ? aReader.ReadUInt64() : (ulong?)null,
aReader.ReadOffset(),
aReader.ReadOffset(),
fCreationOrderIndexed,
fCreationOrderIndexed ? aReader.ReadOffset() : (Offset)null);
return(fToReturn);
}
public static Version2 ReadAfterHeader(
DSHeader aHeader,
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
int
fDimCount = aHeader.Dimensionality;
long
fReadlength = (fDimCount * aReader.SuperBlock.SizeOfLengths);
Flags
fHeaderFlags = (Flags)aHeader.Flags;
bool
fHasMax = fHeaderFlags.HasFlag(Flags.HasMax);
if (fHasMax)
{
fReadlength *= 2;
}
if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < fReadlength)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
DataSpaceType
fType;
switch (aHeader.Type)
{
case (byte)DataSpaceType.Scaler:
case (byte)DataSpaceType.Simple:
case (byte)DataSpaceType.Null:
fType = (DataSpaceType)aHeader.Type;
break;
default:
throw new System.IO.InvalidDataException("Unknown DataSpaceType");
}
aBytes = fReadlength;
Dimension[]
fDimensions = ReadDimensions(
aReader,
fHasMax,
fDimCount);
return(new Version2(fType, fDimensions));
}
public void Test_Data_Space_V2_Special_Parsing(
[Values(uObjects.DataSpaceType.Null,
uObjects.DataSpaceType.Scaler)]
uObjects.DataSpaceType aType)
{
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write((byte)2); //Version 2
fWriter.Write((byte)0); //Dimensionality
fWriter.Write((byte)0x1); //Flags, Has Max
fWriter.Write((byte)aType);
fTestSource.Seek(0, SeekOrigin.Begin);
Mock <ndf5.Metadata.ISuperBlock>
fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose);
fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)8);
fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)8);
Hdf5Reader
fReader = new Hdf5Reader(fTestSource, fSuperBlock.Object);
//Act
long fRead;
uMessages.Message fTest = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Dataspace,
uMessages.MessageAttributeFlag.None,
null,
out fRead);
uMessages.Dataspace
fResult = fTest as uMessages.Dataspace;
//Assert
Assert.That(fResult,
Is.Not.Null,
"Incorrect Message Type returned");
Assert.That(fResult.Dimensions.Count,
Is.EqualTo(0),
"Incorrect Dimensions");
Assert.That(fRead,
Is.EqualTo(fTestSource.Position),
"Incorrect Read Bytes");
Assert.That(fResult.DataSpaceType,
Is.EqualTo(aType),
"Incorrect object type");
}
}
/// <summary>
/// Reads the message at the current location of an Hdf5Reader
/// </summary>
/// <returns>The message.</returns>
/// <param name="aReader">A reader.</param>
/// <param name="aReadFlags">Flags that describe how to handle this message</param>
/// <param name="aMessageType">Type of message to read</param>
public static Message Read(
Hdf5Reader aReader,
MessageType aMessageType,
MessageAttributeFlag aReadFlags)
{
long
aDummy;
return(Read(
aReader,
aMessageType,
aReadFlags,
null,
out aDummy));
}
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 Node(Hdf5Reader aReader, Offset aLocation) : base(
BTreeVerson.One,
aLocation ?? aReader.Position)
{
aReader.VerifySignature(Signature);
byte
fType = (byte)aReader.ReadByte();
if (fType > (byte)NodeType.Data)
{
throw new InvalidDataException($"Unexpected Node Type: {fType}");
}
this.NodeType = (NodeType)fType;
this.NodeLevel = (byte)aReader.ReadByte();
this.EntriesUsed = aReader.ReadUInt16();
this.LeftSibling = aReader.ReadOffset();
this.RightSibling = aReader.ReadOffset();
}
internal static Dataspace Read(
Hdf5Reader aReader,
long?aLocalMessageSize,
out long aBytes)
{
if (aLocalMessageSize.HasValue && aLocalMessageSize.Value < DSHeader.Size)
{
throw new ArgumentException("Specified Local Message Size not long enough");
}
DSHeader
fHeader = DSHeader.Read(aReader);
long
fMessageBodySize;
Dataspace
fToRetrun;
long?
fBodySize = aLocalMessageSize.HasValue
? (long?)aLocalMessageSize.Value - DSHeader.Size
: null;
switch (fHeader.Version)
{
case 1:
fToRetrun = Version1.ReadAfterHeader(
fHeader,
aReader,
fBodySize,
out fMessageBodySize);
break;
case 2:
fToRetrun = Version2.ReadAfterHeader(
fHeader,
aReader,
fBodySize,
out fMessageBodySize);
break;
default:
throw new UnknownMessageVersion <Dataspace>(fHeader.Version);
}
aBytes = DSHeader.Size + fMessageBodySize;
return(fToRetrun);
}
/// <summary>
/// Reads the message at the current location of an Hdf5Reader
/// </summary>
/// <returns>The message.</returns>
/// <param name="aReader">A reader.</param>
/// <param name="aReadFlags">Flags that describe how to handle this message</param>
/// <param name="aMessageType">Type of message to read</param>
/// <param name="aLocalMessageSize">Number of bytes to read</param>
/// <param name="aBytes">Number of bytes that were actually read</param>
public static Message Read(
Hdf5Reader aReader,
MessageType aMessageType,
MessageAttributeFlag aReadFlags,
long?aLocalMessageSize,
out long aBytes)
{
switch (aMessageType)
{
case MessageType.NIL:
aBytes = 0;
return(new Nil());
case MessageType.Dataspace:
return(Dataspace.Read(
aReader,
aLocalMessageSize,
out aBytes));
case MessageType.LinkInfo:
return(LinkInfo.Read(
aReader,
aLocalMessageSize,
out aBytes));
case MessageType.Datatype:
return(Datatype.Read(
aReader,
aLocalMessageSize,
out aBytes));
default:
if (aReadFlags.HasFlag(MessageAttributeFlag.MustUnderstandToRead))
{
throw new Exceptions.RequiredMessageNotUnderstood(
$"Message type {aMessageType} must be understood for this object to be valid");
}
break;
}
throw new NotImplementedException();//TODO: Add 'Not Undestood' message
}
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));
}
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 void TestBasicNilRead(
[Values] uMessages.MessageAttributeFlag aFlags,
[Values(2, 4, 8)] int aOffsetBytes,
[Values(2, 4, 8)] int aLengthBytes)
{
Mock <ndf5.Metadata.ISuperBlock>
fSuperBlock = new Mock <ndf5.Metadata.ISuperBlock>(MockBehavior.Loose);
fSuperBlock.SetupGet(a => a.SizeOfOffsets).Returns((byte)aOffsetBytes);
fSuperBlock.SetupGet(a => a.SizeOfLengths).Returns((byte)aLengthBytes);
Hdf5Reader
fReader = new Hdf5Reader(new System.IO.MemoryStream(new byte[0]), fSuperBlock.Object);
uMessages.Message fShortTest = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.NIL,
aFlags);
Assert.That(fShortTest, Is.InstanceOf(typeof(uMessages.Nil)));
}
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 protected static Dimension[] ReadDimensions(
Hdf5Reader aReader,
bool aHasMax,
int aDimCount)
{
Dimension[]
fDimensions;
Length[]
fSizes = Enumerable
.Range(0, aDimCount)
.Select(a =>
{
Length
fLength = aReader.ReadLength();
if (fLength.IsNull())
{
throw new System.IO.InvalidDataException(
"Dimension lengths must have real values");
}
return(fLength);
})
.ToArray();
if (aHasMax)
{
fDimensions = fSizes.Zip(
Enumerable.Range(0, aDimCount)
.Select(a => aReader.ReadLength()),
(aLength, aMax) => new Dimension(aLength, aMax))
.ToArray();
}
else
{
fDimensions = fSizes.Select(a => new Dimension(a)).ToArray();
}
return(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));
}
public IObjectHeader ReadHeaderAt(long aHeaderLocation)
{
using (Hdf5Reader fReader = mrStreamProvider.GetReader())
{
const int
fcHeadBytes = 4;
byte[]
fHead = new byte[fcHeadBytes];
if (fcHeadBytes != fReader.Read(fHead, 0, fcHeadBytes))
{
throw new System.IO.EndOfStreamException(
$"Could not read header at 0x{aHeaderLocation:x16}");
}
if (fHead[0] == 1 && fHead[1] == 0)
{
return(V1ObjectHeader.Read(fHead, fReader));
}
if (fHead.Zip(msrV2Header, (arg1, arg2) => arg1 == arg2).All(a => a))
{
return(V2ObjectHeader.Read(fReader));
}
}
throw new Exceptions.CorruptObjectHeader("Could not determine Header version");
}
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));
}
public void Test_Basic_Parsing(
[Values] uMessages.DatatypeVersion
aVersion,
[Values(ByteOrdering.BigEndian, ByteOrdering.LittleEndian)]
ByteOrdering aByteOrdering,
[Values(0, 1)] byte
aLowPaddingBit,
[Values(0, 1)] byte
aHighPaddingBit,
[Values] bool
aIsSigned,
[Values((uint)0, (uint)0xffffffff), Random(1)] uint
aSize,
[Values((ushort)0, (ushort)0xffff), Random(1)] ushort
aBitOffset,
[Values((ushort)0, (ushort)0xffff), Random(1)] ushort
aBitPrecision)
{
//Arrange
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write((byte)((byte)aVersion << 4));
fWriter.Write((byte)(
(aByteOrdering == ByteOrdering.BigEndian ? 1 : 0) |
(aLowPaddingBit << 1) |
(aHighPaddingBit << 2) |
(aIsSigned ? 0x8 : 0)));
fWriter.Write((byte)0);
fWriter.Write((byte)0);
fWriter.Write(aSize);
fWriter.Write(aBitOffset);
fWriter.Write(aBitPrecision);
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
uTest
fExpected = new uTest(
aSize,
aByteOrdering,
aHighPaddingBit,
aLowPaddingBit,
aIsSigned,
aBitOffset,
aBitPrecision),
fResult = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
null,
out fReadBytes) as uTest;
Assert.That(
fResult,
Is.Not.Null,
"Incorrect Message Type returned");
Assert.That(
fResult,
Is.EqualTo(fExpected),
"Equality check failed");
Assert.That(
fResult,
Is.Not.EqualTo(new uTest(
aSize,
aByteOrdering,
aHighPaddingBit,
aLowPaddingBit,
aIsSigned,
aBitOffset,
(ushort)(aBitPrecision + 1))),
"Inequality Check Failed");
Assert.That(
fResult,
Is.Not.EqualTo(null),
"Null Inequality Check Failed");
Assert.That(
fResult.GetHashCode(),
Is.EqualTo(fExpected.GetHashCode()),
"Hash Code Equality check failed");
Assert.That(
fReadBytes,
Is.EqualTo(12),
"Wrong number of bytes read");
Assert.That(
fTestSource.Position,
Is.EqualTo(12),
"Wrong number of bytes read");
Assert.That(
fResult.Class,
Is.EqualTo(uMessages.DatatypeClass.FixedPoint),
"Incorrect Data class");
Assert.That(
fResult.ByteOrdering,
Is.EqualTo(aByteOrdering),
"Incorrect byte ordering");
Assert.That(
fResult.LowPaddingBit,
Is.EqualTo(aLowPaddingBit),
"Incorrect low bit padding");
Assert.That(
fResult.HighPaddingBit,
Is.EqualTo(aHighPaddingBit),
"Incorrect high bit padding");
Assert.That(
fResult.IsSigned,
Is.EqualTo(aIsSigned),
"Incorrect value for IsSigned");
Assert.That(
fResult.Size,
Is.EqualTo(aSize),
"Incorrect Data Element Size");
Assert.That(
fResult.BitOffset,
Is.EqualTo(aBitOffset),
"Incorrect bit offset");
Assert.That(
fResult.BitPrecision,
Is.EqualTo(aBitPrecision),
"Incorrect bit precision");
}
}
}
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);
}
private ISuperBlock ParseV0orV1(SuperBlockObj aContainer, bool aIsV1)
{
using (Stream fStream = mrStreamProvider.GetReadonlyStream())
{
fStream.Seek(
(long)(ulong)aContainer.LocationAddress + FormatSignatureAndVersionInfo.Length,
SeekOrigin.Begin);
const byte
fcHeaderBytes = 15;
byte[]
fHeadbuffer = new byte[fcHeaderBytes];
if (fcHeaderBytes != fStream.Read(fHeadbuffer, 0, fcHeaderBytes))
{
throw new EndOfStreamException("Could not read Superblock");
}
aContainer.FreeSpaceStorageVersion = fHeadbuffer[0];
aContainer.RootGroupSymbolTableVersion = fHeadbuffer[1];
if (fHeadbuffer[2] != 0)
{
throw new InvalidDataException("Reserved byte expected to be zero");
}
aContainer.SharedHeaderMessageFormatVersion = fHeadbuffer[3];
aContainer.SizeOfOffsets = fHeadbuffer[4];
aContainer.SizeOfLengths = fHeadbuffer[5];
if (fHeadbuffer[6] != 0)
{
throw new InvalidDataException("Reserved byte expected to be zero");
}
aContainer.GroupLeafNodeK = (ushort)(fHeadbuffer[7] | (fHeadbuffer[8] << 8));
aContainer.GroupInternalNodeK = (ushort)(fHeadbuffer[9] | (fHeadbuffer[10] << 8));
if (aIsV1)
{
const int
fcV1FeildBytes = 4;
byte[]
fV1Buffer = new byte[fcV1FeildBytes];
if (fcV1FeildBytes != fStream.Read(fV1Buffer, 0, fcV1FeildBytes))
{
throw new EndOfStreamException("Could not read Superblock");
}
aContainer.IndexedStorageInternalNodeK = (ushort)(fV1Buffer[0] + (fV1Buffer[1] << 8));
if (!(fV1Buffer[2] == 0 || fV1Buffer[3] == 0))
{
throw new InvalidDataException("Reserved bytes expected to be zero");
}
}
aContainer.BaseAddress = aContainer.LocationAddress;
using (Hdf5Reader fReader = new Hdf5Reader(fStream, aContainer, false))
{
Offset
fBaseAddress = fReader.ReadOffset(),
fFreeSpaceAddress = fReader.ReadOffset(),
fEndOfFileAddress = fReader.ReadOffset(),
fDirverInformationBlockAddress = fReader.ReadOffset();
SymbolTableEntry
fRootGroupEntry = SymbolTableEntry.Read(fReader);
if (fBaseAddress.IsNull())
{
throw new InvalidDataException("No base adddress Specified");
}
aContainer.BaseAddress = fBaseAddress;
aContainer.FileFreespaceInfoAddress = fFreeSpaceAddress;
if (fEndOfFileAddress.IsNull())
{
throw new InvalidDataException("No End Of file Adddress Specified");
}
aContainer.EndOfFileAddress = fEndOfFileAddress;
aContainer.DriverInformationBlockAddress = fDirverInformationBlockAddress;
aContainer.RootGroupSymbolTableEntry = fRootGroupEntry;
aContainer.RootGroupAddress = fRootGroupEntry.ObjectHeaderAddress;
}
}
return(aContainer);
}
public void Test_Float_Example()
{
//Arrange
using (Stream fTestSource = new MemoryStream())
using (BinaryWriter fWriter = new BinaryWriter(fTestSource))
{
fWriter.Write(new byte[] {
0x11, 0x10, 0x1F, 0x00,
0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x20, 0x00,
0x17, 0x08, 0x00, 0x17,
0x7e, 0x00, 0x00, 0x00,
});
fTestSource.Seek(0, SeekOrigin.Begin);
Moq.Mock <ndf5.Metadata.ISuperBlock>
fSuperblock = new Moq.Mock <ndf5.Metadata.ISuperBlock>(
Moq.MockBehavior.Loose);
using (Hdf5Reader fReader = new Hdf5Reader(
fTestSource,
fSuperblock.Object))
{
long
fReadBytes;
uTest fResult = ndf5.Messages.Message.Read(
fReader,
uMessages.MessageType.Datatype,
uMessages.MessageAttributeFlag.None,
null,
out fReadBytes) as uTest;
Assert.That(
fResult,
Is.Not.Null,
"Incorrect Message Type returned");
Assert.That(
fReadBytes,
Is.EqualTo(20),
"Wrong number of bytes read");
Assert.That(
fTestSource.Position,
Is.EqualTo(20),
"Wrong number of bytes read");
Assert.That(
fResult.Class,
Is.EqualTo(uMessages.DatatypeClass.FloatingPoint),
"Incorrect Data class");
Assert.That(
fResult.ByteOrdering,
Is.EqualTo(ByteOrdering.LittleEndian),
"Incorrect byte ordering");
Assert.That(
fResult.LowPaddingBit,
Is.EqualTo(0),
"Incorrect low bit padding");
Assert.That(
fResult.HighPaddingBit,
Is.EqualTo(0),
"Incorrect high bit padding");
Assert.That(
fResult.InternalPaddingBit,
Is.EqualTo(0),
"Incorrect internal bit padding");
Assert.That(
fResult.SignLocation,
Is.EqualTo(31),
"Incorrect Sign bit location");
Assert.That(
fResult.Size,
Is.EqualTo(4),
"Incorrect Data Element Size");
Assert.That(
fResult.BitOffset,
Is.EqualTo(0),
"Incorrect bit offset");
Assert.That(
fResult.BitPrecision,
Is.EqualTo(32),
"Incorrect bit precision");
}
}
}