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