public static RecordType ReadNextRecordType( IBinaryReadStream reader) { var header = reader.ReadInt32(); return(new RecordType(header)); }
public static GroupListOverlay <T> Factory( IBinaryReadStream stream, ReadOnlyMemorySlice <byte> data, BinaryOverlayFactoryPackage package, ObjectType objectType, int offset) { List <int> locations = new List <int>(); stream.Position -= package.MetaData.Constants.GroupConstants.HeaderLength; var groupMeta = stream.GetGroup(package); var finalPos = stream.Position + groupMeta.TotalLength; stream.Position += package.MetaData.Constants.GroupConstants.HeaderLength; // Parse locations while (stream.Position < finalPos) { VariableHeader meta = package.MetaData.Constants.Constants(objectType).VariableMeta(stream.RemainingMemory); locations.Add(checked ((int)stream.Position - offset)); stream.Position += checked ((int)meta.TotalLength); } return(new GroupListOverlay <T>( locations, data, package)); }
public MutagenInterfaceReadStream( IBinaryReadStream stream, ParsingBundle metaData, long offsetReference = 0) { _readStream = stream; this.MetaData = metaData; this.OffsetReference = offsetReference; }
public static RecordType GetNextRecordType( IBinaryReadStream reader, RecordTypeConverter?recordTypeConverter = null) { var header = reader.GetInt32(); var ret = new RecordType(header); ret = recordTypeConverter.ConvertToStandard(ret); return(ret); }
public bool TryGetGroupFrame(IBinaryReadStream stream, out GroupFrame frame, int offset = 0, bool checkIsGroup = true) { if (!TryGetGroup(stream, out var meta, offset: offset, checkIsGroup: checkIsGroup)) { frame = default; return(false); } frame = new GroupFrame(meta, stream.GetSpan(checked ((int)meta.TotalLength))); return(true); }
public bool TryReadGroupMemoryFrame(IBinaryReadStream stream, out GroupMemoryFrame frame, bool checkIsGroup = true, bool readSafe = true) { if (!TryGetGroup(stream, out var meta, checkIsGroup: checkIsGroup)) { frame = default; return(false); } frame = new GroupMemoryFrame(meta, stream.ReadMemory(checked ((int)meta.TotalLength), readSafe)); return(true); }
public bool TryReadSubrecord(IBinaryReadStream stream, out SubrecordHeader meta) { if (stream.Remaining < SubConstants.HeaderLength) { meta = default; return(false); } meta = ReadSubrecord(stream); return(true); }
public bool TryGetSubrecord(IBinaryReadStream stream, RecordType targetType, out SubrecordHeader meta) { if (stream.Remaining < SubConstants.HeaderLength) { meta = default; return(false); } meta = GetSubrecord(stream); return(targetType == meta.RecordType); }
public SubrecordHeader ReadSubrecord(IBinaryReadStream stream, RecordType targetType) { var meta = ReadSubrecord(stream); if (meta.RecordType != targetType) { throw new ArgumentException($"Unexpected header type: {meta.RecordType}"); } return(meta); }
public bool TryReadSubrecordFrame(IBinaryReadStream stream, RecordType targetType, out SubrecordFrame frame) { if (!TryGetSubrecord(stream, targetType, out var meta)) { frame = default; return(false); } frame = new SubrecordFrame(meta, stream.ReadSpan(meta.TotalLength)); return(true); }
public static RecordType ReadNextRecordType( IBinaryReadStream reader, int lengthLength, out int contentLength) { var ret = ReadNextRecordType(reader); contentLength = ReadContentLength(reader, lengthLength); return(ret); }
public bool TryReadGroup(IBinaryReadStream stream, out GroupHeader header, bool checkIsGroup = true) { if (stream.Remaining < GroupConstants.HeaderLength) { header = default; return(false); } header = ReadGroup(stream); return(!checkIsGroup || header.IsGroup); }
public bool TryReadMod(IBinaryReadStream stream, out ModHeader header) { if (stream.Remaining < this.ModHeaderLength) { header = default; return(false); } header = new ModHeader(this, stream.ReadSpan(this.ModHeaderLength)); return(true); }
public bool TryGetGroup(IBinaryReadStream stream, out GroupHeader meta, int offset = 0, bool checkIsGroup = true) { if (stream.Remaining < GroupConstants.HeaderLength + offset) { meta = default; return(false); } meta = GetGroup(stream, offset); return(!checkIsGroup || meta.IsGroup); }
public SubrecordMemoryFrame ReadSubrecordMemoryFrame(IBinaryReadStream stream, RecordType targetType, bool readSafe = false) { var meta = GetSubrecord(stream); if (meta.RecordType != targetType) { throw new ArgumentException($"Unexpected header type: {meta.RecordType}"); } return(new SubrecordMemoryFrame(meta, stream.ReadMemory(meta.TotalLength, readSafe: readSafe))); }
public bool TryReadSubrecordMemoryFrame(IBinaryReadStream stream, RecordType targetType, out SubrecordMemoryFrame frame, bool readSafe = false) { if (!TryGetSubrecord(stream, targetType, out var meta)) { frame = default; return(false); } frame = new SubrecordMemoryFrame(meta, stream.ReadMemory(meta.TotalLength, readSafe: readSafe)); return(true); }
public SubrecordFrame ReadSubrecordFrame(IBinaryReadStream stream, RecordType targetType) { var meta = GetSubrecord(stream); if (meta.RecordType != targetType) { throw new ArgumentException($"Unexpected header type: {meta.RecordType}"); } return(new SubrecordFrame(meta, stream.ReadSpan(meta.TotalLength))); }
public bool TryGetSubrecord(IBinaryReadStream stream, out SubrecordHeader meta, int offset = 0) { if (stream.Remaining < SubConstants.HeaderLength + offset) { meta = default; return(false); } meta = GetSubrecord(stream, offset); return(true); }
public static void FillModTypes( IBinaryReadStream stream, ModTypeFillWrapper fill, BinaryOverlayFactoryPackage package) { int? lastParsed = null; ModHeader headerMeta = stream.GetModHeader(package); var minimumFinalPos = checked ((int)(stream.Position + headerMeta.TotalLength)); fill( stream: stream, finalPos: minimumFinalPos, offset: 0, type: headerMeta.RecordType, lastParsed: lastParsed, recordTypeConverter: null); stream.Position = (int)headerMeta.TotalLength; while (!stream.Complete) { GroupHeader groupMeta = stream.GetGroup(package); if (!groupMeta.IsGroup) { throw new ArgumentException("Did not see GRUP header as expected."); } if (groupMeta.ContentLength == 0) { stream.Position += groupMeta.TotalLength; continue; } minimumFinalPos = checked ((int)(stream.Position + groupMeta.TotalLength)); var parsed = fill( stream: stream, finalPos: minimumFinalPos, offset: 0, type: groupMeta.ContainedRecordType, lastParsed: lastParsed, recordTypeConverter: null); if (!parsed.KeepParsing) { break; } if (!parsed.KeepParsing) { break; } if (minimumFinalPos > stream.Position) { stream.Position = checked ((int)minimumFinalPos); } lastParsed = parsed.ParsedIndex; } }
private static void Read(PexFile file, IBinaryReadStream br) { var magic = br.ReadUInt32(); if (magic != PexMagic) { throw new InvalidDataException($"File does not have fast code! Magic does not match {PexMagic:x8} is {magic:x8}"); } file.MajorVersion = br.ReadUInt8(); file.MinorVersion = br.ReadUInt8(); file.GameId = br.ReadUInt16(); file.CompilationTime = br.ReadUInt64().ToDateTime(); file.SourceFileName = br.ReadPrependedString(2); file.Username = br.ReadPrependedString(2); file.MachineName = br.ReadPrependedString(2); var stringsCount = br.ReadUInt16(); var bundle = new PexParseMeta( file._gameCategory, br, new Dictionary <ushort, string>()); for (var i = 0; i < stringsCount; i++) { bundle.Strings.Add((ushort)i, br.ReadPrependedString(2)); } var hasDebugInfo = bundle.Reader.ReadUInt8() == 1; if (hasDebugInfo) { file.DebugInfo = Mutagen.Bethesda.Pex.DebugInfo.Create(bundle); } var userFlagCount = br.ReadUInt16(); for (var i = 0; i < userFlagCount; i++) { var str = bundle.ReadString(); file.UserFlags[br.ReadUInt8()] = str; } var objectCount = br.ReadUInt16(); for (var i = 0; i < objectCount; i++) { var pexObject = PexObject.Create(bundle); file.Objects.Add(pexObject); } }
public VariableHeader ReadNextRecordVariableMeta(IBinaryReadStream stream) { RecordType rec = new RecordType(stream.GetInt32()); if (rec == Mutagen.Bethesda.Internals.Constants.Group) { return(this.GroupConstants.VariableMeta(stream.ReadSpan(this.GroupConstants.HeaderLength))); } else { return(this.MajorConstants.VariableMeta(stream.ReadSpan(this.MajorConstants.HeaderLength))); } }
public static GenderedItem <TItem> Parse <TItem>( IBinaryReadStream reader, BinarySubParseDelegate <IBinaryReadStream, TItem> transl) { if (!transl(reader, out var male)) { throw new ArgumentException(); } if (!transl(reader, out var female)) { throw new ArgumentException(); } return(new GenderedItem <TItem>(male, female)); }
public static bool TryParseRecordType( IBinaryReadStream reader, int lengthLength, RecordType expectedHeader) { if (TryParse( reader, expectedHeader, out var contentLength, lengthLength)) { return(true); } return(false); }
public static long Parse( IBinaryReadStream reader, RecordType expectedHeader, int lengthLength) { if (!TryParse( reader, expectedHeader, out var contentLength, lengthLength)) { throw new ArgumentException($"Expected header was not read in: {expectedHeader}"); } return(contentLength); }
public bool TryReadSubrecord(IBinaryReadStream stream, RecordType targetType, out SubrecordHeader meta) { if (stream.Remaining < SubConstants.HeaderLength) { meta = default; return(false); } meta = ReadSubrecord(stream); if (meta.RecordType != targetType) { stream.Position -= meta.HeaderLength; return(false); } return(true); }
public static bool TryGetRecordType( IBinaryReadStream reader, RecordType expectedHeader) { if (reader.Remaining < Constants.HeaderLength) { return(false); } var header = reader.GetInt32(); if (expectedHeader.TypeInt != header) { return(false); } return(true); }
public static GroupMajorRecordCacheWrapper <T> Factory( IBinaryReadStream stream, ReadOnlyMemorySlice <byte> data, BinaryOverlayFactoryPackage package, int offset) { Dictionary <FormKey, int> locationDict = new Dictionary <FormKey, int>(); stream.Position -= package.MetaData.Constants.GroupConstants.HeaderLength; var groupMeta = stream.GetGroup(package.MetaData); var finalPos = stream.Position + groupMeta.TotalLength; stream.Position += package.MetaData.Constants.GroupConstants.HeaderLength; // Parse MajorRecord locations ObjectType?lastParsed = default; while (stream.Position < finalPos) { VariableHeader varMeta = package.MetaData.Constants.NextRecordVariableMeta(stream.RemainingMemory); if (varMeta.IsGroup) { if (lastParsed != ObjectType.Record) { throw new DataMisalignedException("Unexpected Group encountered which was not after a major record: " + GroupRecordTypeGetter <T> .GRUP_RECORD_TYPE); } stream.Position += checked ((int)varMeta.TotalLength); lastParsed = ObjectType.Group; } else { MajorRecordHeader majorMeta = package.MetaData.Constants.MajorRecord(stream.RemainingMemory); if (majorMeta.RecordType != GroupRecordTypeGetter <T> .GRUP_RECORD_TYPE) { throw new DataMisalignedException("Unexpected type encountered when parsing MajorRecord locations: " + majorMeta.RecordType); } var formKey = FormKey.Factory(package.MetaData.MasterReferences !, majorMeta.FormID.Raw); locationDict.Add(formKey, checked ((int)(stream.Position - offset))); stream.Position += checked ((int)majorMeta.TotalLength); lastParsed = ObjectType.Record; } } return(new GroupMajorRecordCacheWrapper <T>( locationDict, data, package)); }
public static bool TryParse( IBinaryReadStream reader, RecordType expectedHeader, out long contentLength, long lengthLength) { if (TryGet( reader, expectedHeader, out contentLength, lengthLength)) { reader.Position += Constants.HeaderLength + lengthLength; return(true); } return(false); }
public static ReadOnlyMemorySlice <byte> LockExtractMemory(IBinaryReadStream stream, long min, long max) { lock (stream) { stream.Position = min; var size = checked ((int)(max - min)); if (stream.IsPersistantBacking) { return(stream.ReadMemory(size)); } else { byte[] data = new byte[size]; stream.Read(data); return(data); } } }
protected static int ReadContentLength( IBinaryReadStream reader, int lengthLength) { switch (lengthLength) { case 1: return(reader.ReadUInt8()); case 2: return(reader.ReadUInt16()); case 4: return((int)reader.ReadUInt32()); default: throw new NotImplementedException(); } }