protected override void InternalGuardedExecute(MigrationParameters parameters) { System.Console.WriteLine(); using(StreamReader streamReader = new BufferedStreamReader(parameters.MdlFileName, true)) ServiceProvider.GetService<IMigrationService>().Migrate(parameters.ConnectionString, parameters.VersionOrStep.Value, streamReader); }
internal JavaScriptDeserializer(Stream stream) { if (stream == null) { throw new ArgumentNullException(nameof(stream)); } Stream incomingStream = stream; if (!stream.CanSeek) { //Incoming stream if not seekable then read it in to memory. incomingStream = new BufferedStreamReader(stream); } Encoding streamEncoding = DetectEncoding(incomingStream.ReadByte(), incomingStream.ReadByte()); //Move the stream back to 0 incomingStream.Position = 0; //If the stream contains a BOM, StreamReader will detect it and override our encoding setting string input = new StreamReader(incomingStream, streamEncoding, true/*detectEncodingFromByteOrderMarks*/).ReadToEnd(); if (string.IsNullOrEmpty(input)) { throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationException(SR.Format(SR.ExpectingElement, XmlDictionaryString.Empty, "root"))); } _deserializer = new JavaScriptObjectDeserializer(input); }
// Methods public JavaScriptDeserializer(Stream stream) { if (stream == null) { throw new ArgumentNullException("stream"); } Stream stream2 = stream; if (!stream.CanSeek) { stream2 = new BufferedStreamReader(stream); } Encoding encoding = DetectEncoding(stream2.ReadByte(), stream2.ReadByte()); stream2.Position = 0L; string input = new StreamReader(stream2, encoding, true).ReadToEnd(); this.deserializer = new JavaScriptObjectDeserializer(input); }
public void BufferedStreamReaderGetStruct(BufferedStreamReader bufferedStreamReader, out Quadnode randomQuadnode) { bufferedStreamReader.Read(out randomQuadnode); }
private static EndianStreamReader GetStreamFromEndian(Stream stream, bool bigEndian, int bufferSize, out BufferedStreamReader streamReader) { streamReader = new BufferedStreamReader(stream, bufferSize); return(bigEndian ? new BigEndianStreamReader(streamReader) : new LittleEndianStreamReader(streamReader)); }
/// <summary> /// Returns true if the current archive is an entry for the specified archive name. /// </summary> public bool IsFirstEntry(BufferedStreamReader streamReader, Func <int, int> memoryToRawAddress, DatFileEntry nextEntry, string expectedArchiveName) { return(Sector == 0 && (GetName(streamReader, memoryToRawAddress) == expectedArchiveName) && SizeBytes == nextEntry.SizeBytes && SizeMulBy16 == nextEntry.SizeMulBy16); }
/// <summary> /// Reads an archive from a stream. /// </summary> /// <param name="stream">Stream pointing to the start of the archive.</param> /// <param name="archiveSize">Size of the archive file.</param> public ArchiveReader(Stream stream, int archiveSize) { _stream = stream; _startPos = stream.Position; // Extract Data. using var streamReader = new BufferedStreamReader(stream, 2048); streamReader.Read(out int binCount); Groups = new Group[binCount]; // Get group item counts. for (int x = 0; x < Groups.Length; x++) { Groups[x].Files = new Structs.Parser.File[streamReader.Read <byte>()]; } // Alignment streamReader.Seek(Utilities.Utilities.RoundUp((int)streamReader.Position(), 4) - streamReader.Position(), SeekOrigin.Current); // Skip section containing first item for each group. streamReader.Seek(sizeof(short) * Groups.Length, SeekOrigin.Current); // Populate IDs for (int x = 0; x < Groups.Length; x++) { Groups[x].Id = streamReader.Read <ushort>(); } // Populate offsets. int[] offsets = new int[Groups.Select(x => x.Files.Length).Sum()]; for (int x = 0; x < offsets.Length; x++) { offsets[x] = streamReader.Read <int>(); } int offsetIndex = 0; for (int x = 0; x < Groups.Length; x++) { var fileCount = Groups[x].Files.Length; for (int y = 0; y < fileCount; y++) { // Do not fill if no more elements left. if (offsetIndex >= offsets.Length) { break; } var offset = (int)offsets[offsetIndex]; int nextOffsetIndex = offsetIndex; offsetIndex += 1; // Find next non-zero value within array; if not found, use archive size.. do { nextOffsetIndex += 1; }while (nextOffsetIndex < offsets.Length && offsets[nextOffsetIndex] == 0); var nextOffset = nextOffsetIndex < offsets.Length ? offsets[nextOffsetIndex] : archiveSize; // Set offsets Groups[x].Files[y].Offset = offset; Groups[x].Files[y].Size = nextOffset - offset; } } }
public void BufferedStreamReaderGetStruct(BufferedStreamReader bufferedStreamReader, out RandomIntStruct randomIntStruct) { bufferedStreamReader.Read(out randomIntStruct); }
/// <summary> /// Creates a <see cref="L20n.IO.CharStream"/> instance based on a given string buffer. /// </summary> public CharStream(StreamReader stream, string path = null) { m_Stream = new BufferedStreamReader(stream); m_Buffer = new List <char>(); m_BufferBlock = new char[8]; }
public static void ReadFrom(BufferedStreamReader input, Action <PDU> readAction) { var pdu = ReadHeaderFrom(input); input.Read(pdu.Length, () => readAction.Invoke(pdu)); }
private RunInfo GatherNextRun(BufferedStreamReader reader) { int runLength = 0; return(m_runInfoFactory.GetRunInfo(runLength)); }
/// <summary> /// Constructs a <see cref="EndianStreamReader"/> given an existing stream reader. /// </summary> protected EndianStreamReader(BufferedStreamReader streamReader) => Reader = streamReader;
/// <summary> /// Constructs a <see cref="EndianStreamReader"/> given an existing stream reader. /// </summary> public BigEndianStreamReader(BufferedStreamReader streamReader) : base(streamReader) { }
/// <summary> /// Deserializes the BufferedStreamReader to object /// </summary> /// <typeparam name="TResult">Object type to deserialize to</typeparam> /// <param name="inputStream">BufferedStreamReader to use when deserializing</param> /// <param name="partOfEnum"></param> /// <returns></returns> public static TResult Deserialize <TResult>(BufferedStreamReader inputStream, bool partOfEnum = false) where TResult : class { if (inputStream.EndOfStream) { return(default);
/// <summary> /// Uses file stream to deserialize fixed width file to object /// </summary> /// <typeparam name="TResult">Object type to deserialize file to</typeparam> /// <param name="fileStream">FileStream to use when deserializing</param> /// <returns></returns> public static TResult Deserialize <TResult>(FileStream fileStream) where TResult : class { using (var sr = new BufferedStreamReader(fileStream)) return(Deserialize <TResult>(sr)); }
internal BitReader(BufferedStreamReader input) { _input = input; }
static void DumpFpk(string filePath) { var fileDict = new Dictionary <int, string>(); var storeDict = new Dictionary <int, byte[]>(); var luaFiles = new List <string>(); var refText = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase).Substring(6), "FpkTool.txt"); //Get name references if they exist if (File.Exists(refText)) { Console.WriteLine("FpkTool.txt exists"); using (StreamReader reader = File.OpenText(refText)) { string line; while ((line = reader.ReadLine()) != null) { string[] fileKey = line.Split(' '); fileDict.Add(int.Parse(fileKey[0], System.Globalization.NumberStyles.HexNumber), fileKey[1]); } } } else { Console.WriteLine("FpkTool.txt does not exist"); } //Extract files and apply names if applicable Console.WriteLine("Proceeding..."); if (File.Exists(filePath)) { var fpk = File.ReadAllBytes(filePath); using (var fileStream = new FileStream(filePath, FileMode.Open)) using (var streamReader = new BufferedStreamReader(fileStream, 8192)) { List <FileEntry> table = new List <FileEntry>(); streamReader.Seek(0xC, SeekOrigin.Begin); streamReader.Read <UInt32>(out UInt32 entryCount); for (int i = 0; i < entryCount; i++) { streamReader.Read(out FileEntry value); table.Add(value); } long tableEnd = streamReader.Position(); foreach (FileEntry entry in table) { storeDict.Add(entry.Hash, streamReader.ReadBytes(entry.Offset + tableEnd, (int)entry.Length)); } } var outputDirectory = Path.Combine(Path.GetDirectoryName(filePath), Path.GetFileNameWithoutExtension(filePath)); Directory.CreateDirectory(outputDirectory + "_"); using (StreamWriter fpkList = new StreamWriter(outputDirectory + ".txt")) { foreach (var file in storeDict) { string name; if (fileDict.ContainsKey(file.Key)) { name = fileDict[file.Key]; } else { name = file.Key.ToString("X") + ".lua"; } var fileOutput = Path.Combine(outputDirectory + "_", $"{name}"); File.WriteAllBytes(fileOutput, file.Value); fpkList.WriteLine(file.Key.ToString("X") + " " + name); } } } }
#pragma warning disable 1591 public void ReadEncapsulatedPixelDataFrame(Action <BufferedStreamReader> decodeFrame) { if (!TryReadItemTagOfSequenceWithUndefinedLength()) { throw new Exception($"Expected fragment {DicomTag.Item} but got {CurrentTag}"); } if (ValueLength == UndefinedLength) { throw new Exception($"Fragment {DicomTag.Item} may not have undefined length"); } if (ValueLength > Input.BytesRemaining) { throw new Exception($"Fragment {DicomTag.Item} length exceeds input"); } if (ValueLength == Input.BytesRemaining) { Input.Read(ValueLength, () => { decodeFrame(Input); // Pixel data decoding may end at an uneven byte boundary. // In this case there will be one padding byte left to read if (Input.BytesRemaining == 1) { Input.SkipRemainingBytes(); } }); } else { if (Input.BytesRemaining > int.MaxValue) { throw new NotSupportedException($"Multi-fragment frame length {Input.BytesRemaining} not supported"); } var buffer = ArrayPool <byte> .Shared.Rent((int)Input.BytesRemaining); try { var n = 0; do { var fragmentLength = checked ((int)ValueLength); Input.ReadAll(buffer.AsSpan(n, fragmentLength)); EndReadValue(); n += fragmentLength; }while (TryReadItemTagOfSequenceWithUndefinedLength()); var bufferReader = new BufferedStreamReader(buffer, n); decodeFrame.Invoke(bufferReader); } finally { ArrayPool <byte> .Shared.Return(buffer, clearArray : true); } } }
/// <summary> /// Creates a new Json entry given a DAT file entry. /// </summary> public JsonFileEntry(DatFileEntry entry, BufferedStreamReader stream, Func <int, int> memoryToRawAddress) { Name = entry.GetName(stream, memoryToRawAddress); SizeBytes = entry.SizeBytes; Offset = entry.Sector * DatFileEntry.SECTOR_SIZE_BYTES; }
public LexerContext(Lexer prod, BufferedStreamReader reader) : base(prod) { this.reader = reader; }
/// <summary>Creates a DicomStreamReader for reading DICOM data elements from a stream using the given transfer syntax</summary> public static DicomStreamReader Create(BufferedStreamReader input, DicomUID transferSyntaxUID) { var transferSyntax = new DicomTransferSyntax(transferSyntaxUID); return(new DicomStreamReader(input, transferSyntax)); }
public ConcreteSolver(BufferedStreamReader reader, FormattedStreamWriter writer) { this.reader = reader; this.writer = writer; }
//Takes in bytes of a *n.rel file from PSO //To convert to PSO2's units, we set the scale to 1/10th scale public PSONRelConvert(byte[] file, string fileName = null, float scale = 0.1f, string outFolder = null) { fileSize = file.Length; rootScale = scale; List <dSection> dSections = new List <dSection>(); streamReader = new BufferedStreamReader(new MemoryStream(file), 8192); //Get header offset streamReader.Seek(file.Length - 0x10, SeekOrigin.Begin); //Check Endianness. No offset should ever come close to half of the int max value. be = streamReader.PeekBigEndianPrimitiveUInt32() < streamReader.Peek <uint>(); if (be) { MessageBox.Show("Sorry, Gamecube n.rel files are not supported at this time."); } uint tableOfs = streamReader.ReadBE <uint>(be); //Read header streamReader.Seek(tableOfs, SeekOrigin.Begin); var header = ReadRelHeader(streamReader, be); //Read draw Sections streamReader.Seek(header.drawOffset, SeekOrigin.Begin); for (int i = 0; i < header.drawCount; i++) { dSection section = new dSection(); section.id = streamReader.ReadBE <int>(be); section.pos = streamReader.ReadBEV3(be); var rotX = streamReader.ReadBE <int>(be); var rotY = streamReader.ReadBE <int>(be); var rotZ = streamReader.ReadBE <int>(be); section.rot = new Vector3((float)(rotX * BAMSvalue), (float)(rotY * BAMSvalue), (float)(rotZ * BAMSvalue)); section.radius = streamReader.ReadBE <float>(be); section.staticOffset = streamReader.ReadBE <uint>(be); section.animatedOffset = streamReader.ReadBE <uint>(be); section.staticCount = streamReader.ReadBE <uint>(be); section.animatedCount = streamReader.ReadBE <uint>(be); section.end = streamReader.ReadBE <uint>(be); dSections.Add(section); } //Get texture names streamReader.Seek(header.nameInfoOffset, SeekOrigin.Begin); var nameOffset = streamReader.ReadBE <uint>(be); var nameCount = streamReader.ReadBE <uint>(be); streamReader.Seek(nameOffset, SeekOrigin.Begin); List <uint> nameOffsets = new List <uint>(); for (int i = 0; i < nameCount; i++) { nameOffsets.Add(streamReader.ReadBE <uint>(be)); var unk0 = streamReader.ReadBE <uint>(be); var unk1 = streamReader.ReadBE <uint>(be); if (unk0 != 0) { Console.WriteLine($"Iteration {i} unk0 == {unk0}"); } if (unk1 != 0) { Console.WriteLine($"Iteration {i} unk1 == {unk1}"); } } foreach (uint offset in nameOffsets) { streamReader.Seek(offset, SeekOrigin.Begin); texNames.Add(AquaObjectMethods.ReadCString(streamReader)); } //If there's an .xvm, dump that too with texture names from the .rel if (fileName != null) { //Naming patterns for *n.rel files are *_12n.rel for example or *n.rel vs *.xvm. We can determine which we have, edit, and proceed var basename = fileName.Substring(0, fileName.Length - 5); string xvmName = null; if (basename.ElementAt(basename.Length - 3) == '_') { xvmName = basename.Substring(0, basename.Length - 3) + ".xvm"; } else { xvmName = basename + ".xvm"; } ExtractXVM(xvmName, texNames, outFolder); } //Create root AQN node NODE aqNode = new NODE(); aqNode.animatedFlag = 1; aqNode.parentId = -1; aqNode.unkNode = -1; aqNode.pos = new Vector3(); aqNode.eulRot = new Vector3(); aqNode.scale = new Vector3(1, 1, 1); aqNode.m1 = new Vector4(1, 0, 0, 0); aqNode.m2 = new Vector4(0, 1, 0, 0); aqNode.m3 = new Vector4(0, 0, 1, 0); aqNode.m4 = new Vector4(0, 0, 0, 1); aqNode.boneName.SetString("RootNode"); nodes.Add(aqNode); //Loop through nodes and parse geometry for (int i = 0; i < dSections.Count; i++) { var matrix = Matrix4x4.Identity; matrix *= Matrix4x4.CreateScale(1, 1, 1); var rotation = Matrix4x4.CreateRotationX(dSections[i].rot.X) * Matrix4x4.CreateRotationY(dSections[i].rot.Y) * Matrix4x4.CreateRotationZ(dSections[i].rot.Z); matrix *= rotation; matrix *= Matrix4x4.CreateTranslation(dSections[i].pos * rootScale); //Read static meshes List <staticMeshOffset> staticMeshOffsets = new List <staticMeshOffset>(); streamReader.Seek(dSections[i].staticOffset, SeekOrigin.Begin); for (int st = 0; st < dSections[i].staticCount; st++) { staticMeshOffsets.Add(ReadStaticMeshOffset(streamReader, be)); } for (int ofs = 0; ofs < staticMeshOffsets.Count; ofs++) { streamReader.Seek(staticMeshOffsets[ofs].offset, SeekOrigin.Begin); readNode(matrix, 0); } //Read animated meshes List <animMeshOffset> animatedMeshOffsets = new List <animMeshOffset>(); streamReader.Seek(dSections[i].animatedOffset, SeekOrigin.Begin); for (int st = 0; st < dSections[i].animatedCount; st++) { animatedMeshOffsets.Add(ReadAnimMeshOffset(streamReader, be)); } for (int ofs = 0; ofs < animatedMeshOffsets.Count; ofs++) { streamReader.Seek(animatedMeshOffsets[ofs].offset, SeekOrigin.Begin); readNode(matrix, 0); } } //Set material names for (int i = 0; i < aqObj.tempMats.Count; i++) { aqObj.tempMats[i].matName = $"PSOMat {i}"; } }
public void BufferedStreamReaderGetStructManaged(BufferedStreamReader bufferedStreamReader, out int randomInt) { bufferedStreamReader.Read(out randomInt, true); }
/// <summary> /// Gets the data belonging to an individual file. /// </summary> /// <param name="file">The file to get the data from.</param> public byte[] GetFile(UnpackTextureFile file) { using var streamReader = new BufferedStreamReader(_stream, 2048); return(streamReader.ReadBytes(file.Offset, file.Size)); }
/// <summary> /// Constructs a <see cref="EndianStreamReader"/> given an existing stream reader. /// </summary> public LittleEndianStreamReader(BufferedStreamReader streamReader) : base(streamReader) { }
/// <summary> /// Constructs a <see cref="EndianStreamReader"/> given an existing stream reader. /// </summary> public LittleEndianStreamReader(BufferedStreamReader streamReader, bool disposeUnderlyingStream = true) : base(streamReader, disposeUnderlyingStream) { }
/// <summary> /// Converts the name behind the pointer to a string. /// </summary> public string GetName(BufferedStreamReader streamReader, Func <int, int> memoryToRawAddress) { return(Utilities.Utilities.GetString(streamReader, (long)memoryToRawAddress(NamePtr), Encoding.ASCII)); }