public void Load() { lock (_chunkCache) { string filePath = FilePath; if (!File.Exists(filePath)) { // Welp, nothing to load. IsLoaded = true; return; } using (FileStream regionFile = File.OpenRead(filePath)) { AnvilRegionHeader header = LoadRegionHeader(regionFile); RegionHeader = header; //File.WriteAllLines(FilePath + ".header", header.GetAllChunkData().Select(h => string.Format("{0,-10}\t=>\t{1,-10}\t{2,-10}\t{3,-10}", h.ChunkCoordinates, h.LocationOffset, h.SectorCount, h.UpdatedTimestamp)).ToArray()); foreach (AnvilRegionHeaderChunkData data in header.GetAllChunkData()) { // Attempt to load NbtFile for each chunk. if (!data.ChunkExists) { continue; } regionFile.Seek(data.LocationOffset, SeekOrigin.Begin); var lengthBuffer = new byte[4]; regionFile.Read(lengthBuffer, 0, 4); Array.Reverse(lengthBuffer); int nbtDataLength = BitConverter.ToInt32(lengthBuffer, 0) - 1; int compressionMode = regionFile.ReadByte(); NbtCompression compression = compressionMode == 2 ? NbtCompression.ZLib : (compressionMode == 1 ? NbtCompression.GZip : NbtCompression.None); var nbtDataBuffer = new byte[nbtDataLength]; regionFile.Read(nbtDataBuffer, 0, nbtDataLength); //Debug.WriteLine($"({data.ChunkCoordinates.X}, {data.ChunkCoordinates.Z}) Offset: {data.LocationOffset}, Header Length: {data.SectorCount}, NbtDataLength: {nbtDataLength}"); var nbtFile = new NbtFile(); nbtFile.LoadFromBuffer(nbtDataBuffer, 0, nbtDataLength, compression); //File.WriteAllText(Path.Combine(Provider.BasePath, "region", FileName + $"_{data.ChunkCoordinates.X}-{data.ChunkCoordinates.Z}.txt"), nbtFile.ToString()); //Debug.WriteLine( // $"Region: ({X},{Z}), Chunk({data.ChunkCoordinates.X}, {data.ChunkCoordinates.Z}): NbtDataLength: {nbtDataLength}"); _containingChunks.TryAdd(data.ChunkCoordinates, nbtFile); } } IsLoaded = true; } }
public static NbtCompound LoadRootTagFromFile(string filePath, NbtCompression compression) { NbtFile file = new NbtFile(); file.LoadFromFile(filePath, compression, null); return(file.RootTag); }
/// <summary> /// Saves an NBT tag to a file. /// </summary> /// <param name="file">File to save to.</param> /// <param name="name">Name of the root tag.</param> /// <param name="compression">The compression to use.</param> /// <param name="encoding">The encoding to use for strings. Uses Java's weird MUTF8 encoding by default.</param> /// <param name="endianness">The endianness to use. PC = Big, Pocket Edition = Little.</param> /// <param name="ensureCompound">If true, throws an exception if the root tag isn't a compound.</param> public void Save(string file, string name, NbtCompression compression, Encoding encoding = null, Endianness endianness = Endianness.Big, bool ensureCompound = true) { using (var stream = File.Open(file, FileMode.OpenOrCreate)) WriteTo(stream, name, compression, encoding, endianness, ensureCompound); }
/// <summary> /// Loads an NBT tag from a file. /// </summary> /// <param name="file">File to load from.</param> /// <param name="name">Will be set to the name of the root tag.</param> /// <param name="compression">The compression to use, null or default to auto-detect.</param> /// <param name="encoding">The encoding to use for strings. Uses Java's weird MUTF8 encoding by default.</param> /// <param name="endianness">The endianness to use. PC = Big, Pocket Edition = Little.</param> /// <param name="ensureCompound">If true, throws an exception if the root tag isn't a compound.</param> public static TagBase Load(string file, out string name, NbtCompression compression = null, Encoding encoding = null, Endianness endianness = Endianness.Big, bool ensureCompound = true) { using (var stream = File.OpenRead(file)) return(ReadFrom(stream, out name, compression, encoding, endianness, ensureCompound)); }
/// <summary> Loads NBT data from a stream. </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="NotSupportedException"> If compression is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> public NbtFile([NotNull] Stream stream, NbtCompression compression) { if (stream == null) { throw new ArgumentNullException("stream"); } LoadFromStream(stream, compression); }
public BaseReplayManager(GameManager gameManager, string replayFolder, int queueMaxLength, NbtCompression compressionMethod) { _gameManager = gameManager; _replayFolderPath = replayFolder; _compressionMethod = compressionMethod; _queueMaxLength = queueMaxLength; _replayEvents = new Queue <ReplayEvent <T> >(_queueMaxLength); }
/// <summary> /// Loads an NBT tag from a file. /// Shorthand for ignoring the tag name. /// </summary> /// <param name="file">File to load from.</param> /// <param name="compression">The compression to use, null or default to auto-detect.</param> /// <param name="encoding">The encoding to use for strings. Uses Java's weird MUTF8 encoding by default.</param> /// <param name="endianness">The endianness to use. PC = Big, Pocket Edition = Little.</param> /// <param name="ensureCompound">If true, throws an exception if the root tag isn't a compound.</param> public static TagBase Load(string file, NbtCompression compression = null, Encoding encoding = null, Endianness endianness = Endianness.Big, bool ensureCompound = true) { string name; return(Load(file, out name, compression, encoding, endianness, ensureCompound)); }
/// <summary> /// Reads an NBT tag from a stream. /// Shorthand for ignoring the tag name. /// </summary> /// <param name="stream">The stream to load from.</param> /// <param name="compression">The compression to use, null or default to auto-detect.</param> /// <param name="encoding">The encoding to use for strings. Uses Java's weird MUTF8 encoding by default.</param> /// <param name="endianness">The endianness to use. PC = Big, Pocket Edition = Little.</param> /// <param name="ensureCompound">If true, throws an exception if the root tag isn't a compound.</param> public static TagBase ReadFrom(Stream stream, NbtCompression compression = null, Encoding encoding = null, Endianness endianness = Endianness.Big, bool ensureCompound = true) { string name; return(ReadFrom(stream, out name, compression, encoding, endianness, ensureCompound)); }
/// <summary> Loads NBT data from a file. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public NbtFile([NotNull] string fileName, NbtCompression compression) { if (fileName == null) { throw new ArgumentNullException("fileName"); } LoadFromFile(fileName, compression); }
public NbtFile GetChunk(long x, long z, long y) { long seek = 4 * (x % 32) + (z % 32) * 32; this.m_Reader.BaseStream.Seek(seek, SeekOrigin.Begin); byte[] offsetBytes = new byte[4] { 0, 0, 0, 0 }; byte[] countBytes = new byte[1] { 0 }; this.m_Reader.BaseStream.Read(offsetBytes, 1, 3); this.m_Reader.BaseStream.Read(countBytes, 0, 1); if (BitConverter.IsLittleEndian) { Array.Reverse(offsetBytes); Array.Reverse(countBytes); } int offset = BitConverter.ToInt32(offsetBytes, 0) * 4096; int count = countBytes[0] * 4096; this.m_Reader.BaseStream.Seek(offset, SeekOrigin.Begin); byte[] lengthBytes = new byte[4]; byte[] compressionBytes = new byte[1]; this.m_Reader.BaseStream.Read(lengthBytes, 0, 4); this.m_Reader.BaseStream.Read(compressionBytes, 0, 1); if (BitConverter.IsLittleEndian) { Array.Reverse(lengthBytes); Array.Reverse(compressionBytes); } int length = BitConverter.ToInt32(lengthBytes, 0) * 4096; int compression = compressionBytes[0] * 4096; NbtCompression nbtComp = NbtCompression.AutoDetect; /*switch (compression) * { * case 0: * nbtComp = NbtCompression.None; * break; * case 1: * nbtComp = NbtCompression.GZip; * break; * case 2: * nbtComp = NbtCompression.ZLib; * break; * }*/ if (length == 0) { return(null); } byte[] data = new byte[length]; MemoryStream mem = new MemoryStream(data); this.m_Reader.BaseStream.Read(data, 0, length); return(new NbtFile(mem, nbtComp)); }
void LoadFromStreamInternal(String fileName, NbtCompression compression) { var file = new NbtFile(); byte[] fileBytes = File.ReadAllBytes(fileName); using (var ms = new MemoryStream(fileBytes)) { file.LoadFromStream(ms, compression); } }
// keep this private and only expose the static constructors below so callers don't have to include irrelevant information private ExportSettings(bool snbt, bool minified, bool json, NbtCompression compression, bool big_endian, bool bedrock_header) { Snbt = snbt; Minified = minified; Json = json; Compression = compression; BigEndian = big_endian; BedrockHeader = bedrock_header; }
public Schematic(short width, short length, short height, NbtCompression compression = NbtCompression.None) { Width = width; Length = length; Height = height; Blocks = new byte[width * length * height]; Data = new byte[Blocks.Length]; Compression = compression; }
public static string ReadRootTagName([NotNull] Stream stream, NbtCompression compression, bool bigEndian, int bufferSize) { if (stream == null) { throw new ArgumentNullException("stream"); } if (bufferSize < 0) { throw new ArgumentOutOfRangeException("bufferSize", bufferSize, "DefaultBufferSize cannot be negative."); } // detect compression, based on the first byte if (compression == NbtCompression.AutoDetect) { compression = DetectCompression(stream); } switch (compression) { case NbtCompression.GZip: using (var decStream = new GZipStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { return(GetRootNameInternal(new BufferedStream(decStream, bufferSize), bigEndian)); } else { return(GetRootNameInternal(decStream, bigEndian)); } } case NbtCompression.None: return(GetRootNameInternal(stream, bigEndian)); case NbtCompression.ZLib: if (stream.ReadByte() != 0x78) { throw new InvalidDataException(WrongZLibHeaderMessage); } stream.ReadByte(); using (var decStream = new DeflateStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { return(GetRootNameInternal(new BufferedStream(decStream, bufferSize), bigEndian)); } else { return(GetRootNameInternal(decStream, bigEndian)); } } default: throw new ArgumentOutOfRangeException("compression"); } }
public static void SaveTagToFile(NbtCompound rootTag, string filePath, NbtCompression compression) { try { new NbtFile(rootTag).SaveToFile(filePath, compression); }catch (Exception ex) { throw new ReplayException("Unable to save tag to file.", ex); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="buffer"> Buffer to write data to. May not be <c>null</c>. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream should begin. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> is less than zero; or if <paramref name="index"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public long SaveToBuffer([NotNull] byte[] buffer, int index, NbtCompression compression) { if (buffer == null) { throw new ArgumentNullException("buffer"); } using (var ms = new MemoryStream(buffer, index, buffer.Length - index)) { return(SaveToStream(ms, compression)); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="fileName"> File to write data to. May not be <c>null</c>. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="IOException"> If an I/O error occurred while creating the file. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public int SaveToFile([NotNull] string fileName, NbtCompression compression) { if (fileName == null) { throw new ArgumentNullException("fileName"); } using (FileStream saveFile = File.Create(fileName)) { return(SaveToStream(saveFile, compression)); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="buffer"> Buffer to write data to. May not be <c>null</c>. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream should begin. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> is less than zero; or if <paramref name="index"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public int SaveToBuffer([NotNull] byte[] buffer, int index, NbtCompression compression) { if (buffer == null) { throw new ArgumentNullException("buffer"); } using (MemoryStream ms = new MemoryStream(buffer, index, buffer.Length - index)) { SaveToStream(ms, compression); return((int)ms.Position); } }
/// <summary> Loads NBT data from a byte array. Existing <c>RootTag</c> will be replaced. <c>FileName</c> will be set to null. </summary> /// <param name="buffer"> Stream from which data will be loaded. If <paramref name="compression"/> is set to AutoDetect, this stream must support seeking. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream begins. Must not be negative. </param> /// <param name="length"> Maximum number of bytes to read from the given buffer. Must not be negative. /// An <see cref="EndOfStreamException"/> is thrown if NBT stream is longer than the given length. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <returns> Number of bytes read from the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> or <paramref name="length"/> is less than zero; /// if the sum of <paramref name="index"/> and <paramref name="length"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="EndOfStreamException"> If NBT stream extends beyond the given <paramref name="length"/>. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> public long LoadFromBuffer([NotNull] byte[] buffer, int index, int length, NbtCompression compression) { if (buffer == null) { throw new ArgumentNullException("buffer"); } using (var ms = new MemoryStream(buffer, index, length)) { LoadFromStream(ms, compression, null); FileName = null; return(ms.Position); } }
/// <summary> Loads NBT data from a file. Existing <c>RootTag</c> will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public int LoadFromFile([NotNull] string fileName, NbtCompression compression, [CanBeNull] TagSelector selector) { if (fileName == null) { throw new ArgumentNullException("fileName"); } using (FileStream readFileStream = File.OpenRead(fileName)) { LoadFromStream(readFileStream, compression, selector); FileName = fileName; return((int)readFileStream.Position); } }
/// <summary> Loads NBT data from a byte array. Existing <c>RootTag</c> will be replaced. <c>FileName</c> will be set to null. </summary> /// <param name="buffer"> Stream from which data will be loaded. If <paramref name="compression"/> is set to AutoDetect, this stream must support seeking. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream begins. Must not be negative. </param> /// <param name="length"> Maximum number of bytes to read from the given buffer. Must not be negative. /// An <see cref="EndOfStreamException"/> is thrown if NBT stream is longer than the given length. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> or <paramref name="length"/> is less than zero; /// if the sum of <paramref name="index"/> and <paramref name="length"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="EndOfStreamException"> If NBT stream extends beyond the given <paramref name="length"/>. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> public int LoadFromBuffer([NotNull] byte[] buffer, int index, int length, NbtCompression compression, [CanBeNull] TagSelector selector) { if (buffer == null) { throw new ArgumentNullException("buffer"); } using (MemoryStream ms = new MemoryStream(buffer, index, length)) { LoadFromStream(ms, compression, selector); FileName = null; return((int)ms.Position); } }
public NbtReader(Stream input, NbtCompression compressionMode = NbtCompression.None) { if (compressionMode == NbtCompression.GZip) { this.BaseStream = new GZipStream(input, CompressionMode.Decompress); } else if (compressionMode == NbtCompression.ZLib) { this.BaseStream = new ZLibStream(input, CompressionMode.Decompress); } else { this.BaseStream = input; } }
void ReadRootTagInternal(String fileName, NbtCompression compression) { Assert.Throws <ArgumentOutOfRangeException>(() => NbtFile.ReadRootTagName(fileName, compression, true, -1)); Assert.AreEqual("Level", NbtFile.ReadRootTagName(fileName)); Assert.AreEqual("Level", NbtFile.ReadRootTagName(fileName, compression, true, 0)); byte[] fileBytes = File.ReadAllBytes(fileName); using (var ms = new MemoryStream(fileBytes)) { using (var nss = new NonSeekableStream(ms)) { Assert.Throws <ArgumentOutOfRangeException>( () => NbtFile.ReadRootTagName(nss, compression, true, -1)); NbtFile.ReadRootTagName(nss, compression, true, 0); } } }
/// <summary> Loads NBT data from a file. Existing RootTag will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public void LoadFromFile([NotNull] string fileName, NbtCompression compression) { if (fileName == null) { throw new ArgumentNullException("fileName"); } if (!File.Exists(fileName)) { throw new FileNotFoundException(String.Format("Could not find NBT file: {0}", fileName), fileName); } using (FileStream readFileStream = File.OpenRead(fileName)) { LoadFromStream(readFileStream, compression); } FileName = fileName; }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="fileName"> File to write data to. May not be <c>null</c>. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="IOException"> If an I/O error occurred while creating the file. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public long SaveToFile([NotNull] string fileName, NbtCompression compression) { if (fileName == null) { throw new ArgumentNullException("fileName"); } using ( var saveFile = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None, FileStreamBufferSize, FileOptions.SequentialScan)) { return(SaveToStream(saveFile, compression)); } }
void ReloadFileInternal(String fileName, NbtCompression compression, bool bigEndian, bool buffered) { var loadedFile = new NbtFile(Path.Combine(TestFiles.DirName, fileName)) { BigEndian = bigEndian }; if (!buffered) { loadedFile.BufferSize = 0; } long bytesWritten = loadedFile.SaveToFile(Path.Combine(TestDirName, fileName), compression); long bytesRead = loadedFile.LoadFromFile(Path.Combine(TestDirName, fileName), NbtCompression.AutoDetect, null); Assert.AreEqual(bytesWritten, bytesRead); TestFiles.AssertNbtBigFile(loadedFile); }
/// <summary> Loads NBT data from a file. Existing <c>RootTag</c> will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public long LoadFromFile([NotNull] string fileName, NbtCompression compression, [CanBeNull] TagSelector selector) { if (fileName == null) { throw new ArgumentNullException("fileName"); } using ( var readFileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferSize, FileOptions.SequentialScan)) { LoadFromStream(readFileStream, compression, selector); FileName = fileName; return(readFileStream.Position); } }
public void Load() { if (IsCorrupt || IsExternal) { return; } var stream = Region.GetStream(); stream.Seek(Offset + 4, SeekOrigin.Begin); int compression = stream.ReadByte(); if (compression == -1) { IsCorrupt = true; Remove(); } else { if ((compression & (1 << 7)) != 0) { IsExternal = true; ExternalCompression = (byte)compression; } else { var file = new fNbt.NbtFile(); try { file.LoadFromStream(stream, NbtCompression.AutoDetect); Compression = file.FileCompression; SetData(file.GetRootTag <NbtCompound>()); } catch { IsCorrupt = true; Remove(); } } } stream.Dispose(); OnLoaded?.Invoke(this, EventArgs.Empty); }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="stream"> Stream to write data to. May not be <c>null</c>. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the stream. </returns> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="NbtFormatException"> If RootTag is null; /// or if RootTag is unnamed; /// or if one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public long SaveToStream([NotNull] Stream stream, NbtCompression compression) { if (stream == null) throw new ArgumentNullException("stream"); switch (compression) { case NbtCompression.AutoDetect: throw new ArgumentException("AutoDetect is not a valid NbtCompression value for saving."); case NbtCompression.ZLib: case NbtCompression.GZip: case NbtCompression.None: break; default: throw new ArgumentOutOfRangeException("compression"); } if (rootTag.Name == null) { throw new NbtFormatException( "Cannot save NbtFile: Root tag is not named. Its name may be an empty string, but not null."); } long startOffset = 0; if (stream.CanSeek) { startOffset = stream.Position; } else { stream = new ByteCountingStream(stream); } switch (compression) { case NbtCompression.ZLib: stream.WriteByte(0x78); stream.WriteByte(0x01); int checksum; using (var compressStream = new ZLibStream(stream, CompressionMode.Compress, true)) { var bufferedStream = new BufferedStream(compressStream, WriteBufferSize); RootTag.WriteTag(new NbtBinaryWriter(bufferedStream, BigEndian)); bufferedStream.Flush(); checksum = compressStream.Checksum; } byte[] checksumBytes = BitConverter.GetBytes(checksum); if (BitConverter.IsLittleEndian) { // Adler32 checksum is big-endian Array.Reverse(checksumBytes); } stream.Write(checksumBytes, 0, checksumBytes.Length); break; case NbtCompression.GZip: using (var compressStream = new GZipStream(stream, CompressionMode.Compress, true)) { // use a buffered stream to avoid GZipping in small increments (which has a lot of overhead) var bufferedStream = new BufferedStream(compressStream, WriteBufferSize); RootTag.WriteTag(new NbtBinaryWriter(bufferedStream, BigEndian)); bufferedStream.Flush(); } break; case NbtCompression.None: { var writer = new NbtBinaryWriter(stream, BigEndian); RootTag.WriteTag(writer); } break; default: throw new ArgumentOutOfRangeException("compression"); } if (stream.CanSeek) { return stream.Position - startOffset; } else { return ((ByteCountingStream)stream).BytesWritten; } }
public byte[] SaveToBuffer(NbtCompression compression) { using (var ms = new MemoryStream()) { SaveToStream(ms, compression); return ms.ToArray(); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="fileName"> File to write data to. May not be <c>null</c>. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="IOException"> If an I/O error occurred while creating the file. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public long SaveToFile([NotNull] string fileName, NbtCompression compression) { if (fileName == null) throw new ArgumentNullException("fileName"); using ( var saveFile = new FileStream(fileName, FileMode.Create, FileAccess.Write, FileShare.None, FileStreamBufferSize, FileOptions.SequentialScan)) { return SaveToStream(saveFile, compression); } }
/// <summary> Loads NBT data from a stream. Existing <c>RootTag</c> will be replaced </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <returns> Number of bytes read from the stream. </returns> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="NotSupportedException"> If <paramref name="compression"/> is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> public long LoadFromStream([NotNull] Stream stream, NbtCompression compression) { return LoadFromStream(stream, compression, null); }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="buffer"> Buffer to write data to. May not be <c>null</c>. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream should begin. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> is less than zero; or if <paramref name="index"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public long SaveToBuffer([NotNull] byte[] buffer, int index, NbtCompression compression) { if (buffer == null) throw new ArgumentNullException("buffer"); using (var ms = new MemoryStream(buffer, index, buffer.Length - index)) { return SaveToStream(ms, compression); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is null. </summary> /// <param name="fileName"> File to write data to. May not be null. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is null. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the compression mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="IOException"> If an I/O error occurred while creating the file. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public void SaveToFile( [NotNull] string fileName, NbtCompression compression ) { if( fileName == null ) throw new ArgumentNullException( "fileName" ); using( FileStream saveFile = File.Create( fileName ) ) { SaveToStream( saveFile, compression ); } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is <c>null</c>. </summary> /// <param name="buffer"> Buffer to write data to. May not be <c>null</c>. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream should begin. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <returns> Number of bytes written to the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the <paramref name="compression"/> mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> is less than zero; or if <paramref name="index"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="UnauthorizedAccessException"> Specified file is read-only, or a permission issue occurred. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public int SaveToBuffer( [NotNull] byte[] buffer, int index, NbtCompression compression ) { if( buffer == null ) throw new ArgumentNullException( "buffer" ); using( MemoryStream ms = new MemoryStream( buffer, index, buffer.Length - index ) ) { SaveToStream( ms, compression ); return (int)ms.Position; } }
void ReadRootTagInternal(String fileName, NbtCompression compression) { Assert.Throws<ArgumentOutOfRangeException>(() => NbtFile.ReadRootTagName(fileName, compression, true, -1)); Assert.AreEqual("Level", NbtFile.ReadRootTagName(fileName)); Assert.AreEqual("Level", NbtFile.ReadRootTagName(fileName, compression, true, 0)); byte[] fileBytes = File.ReadAllBytes(fileName); using (var ms = new MemoryStream(fileBytes)) { using (var nss = new NonSeekableStream(ms)) { Assert.Throws<ArgumentOutOfRangeException>( () => NbtFile.ReadRootTagName(nss, compression, true, -1)); NbtFile.ReadRootTagName(nss, compression, true, 0); } } }
/// <summary> Saves this NBT file to a stream. Nothing is written to stream if RootTag is null. </summary> /// <param name="stream"> Stream to write data to. May not be null. </param> /// <param name="compression"> Compression mode to use for saving. May not be AutoDetect. </param> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is null. </exception> /// <exception cref="ArgumentException"> If AutoDetect was given as the compression mode. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="InvalidDataException"> If given stream does not support writing. </exception> /// <exception cref="NbtFormatException"> If one of the NbtCompound tags contained unnamed tags; /// or if an NbtList tag had Unknown list type and no elements. </exception> public void SaveToStream( [NotNull] Stream stream, NbtCompression compression ) { if( stream == null ) throw new ArgumentNullException( "stream" ); switch( compression ) { case NbtCompression.AutoDetect: throw new ArgumentException( "AutoDetect is not a valid NbtCompression value for saving." ); case NbtCompression.ZLib: case NbtCompression.GZip: case NbtCompression.None: break; default: throw new ArgumentOutOfRangeException( "compression" ); } // do not write anything for empty tags if( RootTag == null ) return; switch( compression ) { case NbtCompression.ZLib: stream.WriteByte( 0x78 ); stream.WriteByte( 0x01 ); int checksum; using( var compressStream = new ZLibStream( stream, CompressionMode.Compress, true ) ) { BufferedStream bufferedStream = new BufferedStream( compressStream, BufferSize ); RootTag.WriteTag( new NbtWriter( bufferedStream ), true ); bufferedStream.Flush(); checksum = compressStream.Checksum; } byte[] checksumBytes = BitConverter.GetBytes(checksum); if( BitConverter.IsLittleEndian ) { // Adler32 checksum is big-endian Array.Reverse( checksumBytes ); } stream.Write( checksumBytes, 0, checksumBytes.Length ); break; case NbtCompression.GZip: using( var compressStream = new GZipStream( stream, CompressionMode.Compress, true ) ) { // use a buffered stream to avoid gzipping in small increments (which has a lot of overhead) BufferedStream bufferedStream = new BufferedStream( compressStream, BufferSize ); RootTag.WriteTag( new NbtWriter( bufferedStream ), true ); bufferedStream.Flush(); } break; case NbtCompression.None: RootTag.WriteTag( new NbtWriter( stream ), true ); break; } }
/// <summary> Loads NBT data from a file. Existing <c>RootTag</c> will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public int LoadFromFile( [NotNull] string fileName, NbtCompression compression, [CanBeNull] TagSelector selector ) { if( fileName == null ) throw new ArgumentNullException( "fileName" ); using( FileStream readFileStream = File.OpenRead( fileName ) ) { LoadFromStream( readFileStream, compression, selector ); FileName = fileName; return (int)readFileStream.Position; } }
/// <summary> Loads NBT data from a stream. Existing <c>RootTag</c> will be replaced </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <returns> Number of bytes read from the stream. </returns> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="NotSupportedException"> If <paramref name="compression"/> is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> public int LoadFromStream( [NotNull] Stream stream, NbtCompression compression ) { if( stream == null ) throw new ArgumentNullException( "stream" ); FileName = null; FileCompression = compression; // detect compression, based on the first byte if( compression == NbtCompression.AutoDetect ) { compression = DetectCompression( stream ); } long startPosition = stream.Position; switch( compression ) { case NbtCompression.GZip: using( var decStream = new GZipStream( stream, CompressionMode.Decompress, true ) ) { if( bufferSize > 0 ) { LoadFromStreamInternal( new BufferedStream( decStream, bufferSize ), null ); } else { LoadFromStreamInternal( decStream, null ); } } break; case NbtCompression.None: LoadFromStreamInternal( stream, null ); break; case NbtCompression.ZLib: if( stream.ReadByte() != 0x78 ) { throw new InvalidDataException( "Incorrect ZLib header. Expected 0x78 0x9C" ); } stream.ReadByte(); using( var decStream = new DeflateStream( stream, CompressionMode.Decompress, true ) ) { if( bufferSize > 0 ) { LoadFromStreamInternal( new BufferedStream( decStream, bufferSize ), null ); } else { LoadFromStreamInternal( decStream, null ); } } break; default: throw new ArgumentOutOfRangeException( "compression" ); } return (int)( stream.Position - startPosition ); }
/// <summary> Loads NBT data from a stream. </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="NotSupportedException"> If compression is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> public NbtFile( [NotNull] Stream stream, NbtCompression compression ) { if( stream == null ) throw new ArgumentNullException( "stream" ); LoadFromStream( stream, compression ); }
/// <summary> Loads NBT data from a file. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public NbtFile( [NotNull] string fileName, NbtCompression compression ) { if( fileName == null ) throw new ArgumentNullException( "fileName" ); LoadFromFile( fileName, compression ); }
/// <summary> Loads NBT data from a byte array. Existing <c>RootTag</c> will be replaced. <c>FileName</c> will be set to null. </summary> /// <param name="buffer"> Stream from which data will be loaded. If <paramref name="compression"/> is set to AutoDetect, this stream must support seeking. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream begins. Must not be negative. </param> /// <param name="length"> Maximum number of bytes to read from the given buffer. Must not be negative. /// An <see cref="EndOfStreamException"/> is thrown if NBT stream is longer than the given length. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <returns> Number of bytes read from the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> or <paramref name="length"/> is less than zero; /// if the sum of <paramref name="index"/> and <paramref name="length"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="EndOfStreamException"> If NBT stream extends beyond the given <paramref name="length"/>. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> public int LoadFromBuffer([NotNull] byte[] buffer, int index, int length, NbtCompression compression) { if (buffer == null) throw new ArgumentNullException("buffer"); using (var ms = new MemoryStream(buffer, index, length)) { LoadFromStream(ms, compression, null); FileName = null; return (int)ms.Position; } }
/// <summary> Loads NBT data from a file. Existing <c>RootTag</c> will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the file. </returns> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public int LoadFromFile([NotNull] string fileName, NbtCompression compression, [CanBeNull] TagSelector selector) { if (fileName == null) throw new ArgumentNullException("fileName"); using ( var readFileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read, FileStreamBufferSize, FileOptions.SequentialScan)) { LoadFromStream(readFileStream, compression, selector); FileName = fileName; return (int)readFileStream.Position; } }
/// <summary> Loads NBT data from a byte array. Existing <c>RootTag</c> will be replaced. <c>FileName</c> will be set to null. </summary> /// <param name="buffer"> Stream from which data will be loaded. If <paramref name="compression"/> is set to AutoDetect, this stream must support seeking. </param> /// <param name="index"> The index into <paramref name="buffer"/> at which the stream begins. Must not be negative. </param> /// <param name="length"> Maximum number of bytes to read from the given buffer. Must not be negative. /// An <see cref="EndOfStreamException"/> is thrown if NBT stream is longer than the given length. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the buffer. </returns> /// <exception cref="ArgumentNullException"> <paramref name="buffer"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>; /// if <paramref name="index"/> or <paramref name="length"/> is less than zero; /// if the sum of <paramref name="index"/> and <paramref name="length"/> is greater than the length of <paramref name="buffer"/>. </exception> /// <exception cref="EndOfStreamException"> If NBT stream extends beyond the given <paramref name="length"/>. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> public long LoadFromBuffer([NotNull] byte[] buffer, int index, int length, NbtCompression compression, [CanBeNull] TagSelector selector) { if (buffer == null) throw new ArgumentNullException("buffer"); using (var ms = new MemoryStream(buffer, index, length)) { LoadFromStream(ms, compression, selector); FileName = null; return ms.Position; } }
/// <summary> Loads NBT data from a stream. Existing <c>RootTag</c> will be replaced </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <param name="selector"> Optional callback to select which tags to load into memory. Root may not be skipped. /// No reference is stored to this callback after loading (don't worry about implicitly captured closures). May be <c>null</c>. </param> /// <returns> Number of bytes read from the stream. </returns> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is <c>null</c>. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for <paramref name="compression"/>. </exception> /// <exception cref="NotSupportedException"> If <paramref name="compression"/> is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occurred while parsing data in NBT format. </exception> public long LoadFromStream([NotNull] Stream stream, NbtCompression compression, [CanBeNull] TagSelector selector) { if (stream == null) throw new ArgumentNullException("stream"); FileName = null; // detect compression, based on the first byte if (compression == NbtCompression.AutoDetect) { FileCompression = DetectCompression(stream); } else { FileCompression = compression; } // prepare to count bytes read long startOffset = 0; if (stream.CanSeek) { startOffset = stream.Position; } else { stream = new ByteCountingStream(stream); } switch (FileCompression) { case NbtCompression.GZip: using (var decStream = new GZipStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { LoadFromStreamInternal(new BufferedStream(decStream, bufferSize), selector); } else { LoadFromStreamInternal(decStream, selector); } } break; case NbtCompression.None: LoadFromStreamInternal(stream, selector); break; case NbtCompression.ZLib: if (stream.ReadByte() != 0x78) { throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C"); } stream.ReadByte(); using (var decStream = new DeflateStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { LoadFromStreamInternal(new BufferedStream(decStream, bufferSize), selector); } else { LoadFromStreamInternal(decStream, selector); } } break; default: throw new ArgumentOutOfRangeException("compression"); } // report bytes read if (stream.CanSeek) { return stream.Position - startOffset; } else { return ((ByteCountingStream)stream).BytesRead; } }
public static string ReadRootTagName([NotNull] string fileName, NbtCompression compression, bool bigEndian, int bufferSize) { if (fileName == null) { throw new ArgumentNullException("fileName"); } if (!File.Exists(fileName)) { throw new FileNotFoundException("Could not find the given NBT file.", fileName); } if (bufferSize < 0) { throw new ArgumentOutOfRangeException("bufferSize", bufferSize, "DefaultBufferSize cannot be negative."); } using (FileStream readFileStream = File.OpenRead(fileName)) { return ReadRootTagName(readFileStream, compression, bigEndian, bufferSize); } }
/// <summary> Loads NBT data from a file. Existing RootTag will be replaced. </summary> /// <param name="fileName"> Name of the file from which data will be loaded. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="fileName"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, or decompressing failed. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> /// <exception cref="IOException"> If an I/O error occurred while reading the file. </exception> public void LoadFromFile( [NotNull] string fileName, NbtCompression compression ) { if( fileName == null ) throw new ArgumentNullException( "fileName" ); if( !File.Exists( fileName ) ) { throw new FileNotFoundException( String.Format( "Could not find NBT file: {0}", fileName ), fileName ); } using( FileStream readFileStream = File.OpenRead( fileName ) ) { LoadFromStream( readFileStream, compression ); } FileName = fileName; }
/// <summary> Loads NBT data from a stream. Existing RootTag will be replaced </summary> /// <param name="stream"> Stream from which data will be loaded. If compression is set to AutoDetect, this stream must support seeking. </param> /// <param name="compression"> Compression method to use for loading/saving this file. </param> /// <exception cref="ArgumentNullException"> <paramref name="stream"/> is null. </exception> /// <exception cref="ArgumentOutOfRangeException"> If an unrecognized/unsupported value was given for compression. </exception> /// <exception cref="FileNotFoundException"> If given file was not found. </exception> /// <exception cref="NotSupportedException"> If compression is set to AutoDetect, but the stream is not seekable. </exception> /// <exception cref="EndOfStreamException"> If file ended earlier than expected. </exception> /// <exception cref="InvalidDataException"> If file compression could not be detected, decompressing failed, or given stream does not support reading. </exception> /// <exception cref="NbtFormatException"> If an error occured while parsing data in NBT format. </exception> public void LoadFromStream( [NotNull] Stream stream, NbtCompression compression ) { if( stream == null ) throw new ArgumentNullException( "stream" ); FileName = null; FileCompression = compression; // detect compression, based on the first byte if( compression == NbtCompression.AutoDetect ) { if( !stream.CanSeek ) { throw new NotSupportedException( "Cannot auto-detect compression on a stream that's not seekable." ); } int firstByte = stream.ReadByte(); switch( firstByte ) { case -1: throw new EndOfStreamException(); case (byte)NbtTagType.Compound: // 0x0A compression = NbtCompression.None; break; case 0x1F: // gzip magic number compression = NbtCompression.GZip; break; case 0x78: // zlib header compression = NbtCompression.ZLib; break; default: throw new InvalidDataException( "Could not auto-detect compression format." ); } stream.Seek( -1, SeekOrigin.Current ); } switch( compression ) { case NbtCompression.GZip: using( var decStream = new GZipStream( stream, CompressionMode.Decompress, true ) ) { LoadFromStreamInternal( new BufferedStream( decStream, BufferSize ) ); } break; case NbtCompression.None: LoadFromStreamInternal( stream ); break; case NbtCompression.ZLib: if( stream.ReadByte() != 0x78 ) { throw new InvalidDataException( "Incorrect ZLib header. Expected 0x78 0x9C" ); } stream.ReadByte(); using( var decStream = new DeflateStream( stream, CompressionMode.Decompress, true ) ) { LoadFromStreamInternal( new BufferedStream( decStream, BufferSize ) ); } break; default: throw new ArgumentOutOfRangeException( "compression" ); } }
public static string ReadRootTagName([NotNull] Stream stream, NbtCompression compression, bool bigEndian, int bufferSize) { if (stream == null) throw new ArgumentNullException("stream"); if (bufferSize < 0) { throw new ArgumentOutOfRangeException("bufferSize", bufferSize, "DefaultBufferSize cannot be negative."); } // detect compression, based on the first byte if (compression == NbtCompression.AutoDetect) { compression = DetectCompression(stream); } switch (compression) { case NbtCompression.GZip: using (var decStream = new GZipStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { return GetRootNameInternal(new BufferedStream(decStream, bufferSize), bigEndian); } else { return GetRootNameInternal(decStream, bigEndian); } } case NbtCompression.None: return GetRootNameInternal(stream, bigEndian); case NbtCompression.ZLib: if (stream.ReadByte() != 0x78) { throw new InvalidDataException("Incorrect ZLib header. Expected 0x78 0x9C"); } stream.ReadByte(); using (var decStream = new DeflateStream(stream, CompressionMode.Decompress, true)) { if (bufferSize > 0) { return GetRootNameInternal(new BufferedStream(decStream, bufferSize), bigEndian); } else { return GetRootNameInternal(decStream, bigEndian); } } default: throw new ArgumentOutOfRangeException("compression"); } }