private void LoadFromStreamInternal([NotNull] Stream stream, [CanBeNull] TagSelector tagSelector)
{
var reader = new NbtBinaryReader(stream, BigEndian)
{
Selector = tagSelector,
UseVarInt = UseVarInt
};
RootTag = NbtTag.ReadUnknownTag(reader);
//else {
// // Make sure the first byte in this file is the tag for a TAG_Compound
// int firstByte = stream.ReadByte();
// if (firstByte < 0)
// {
// throw new EndOfStreamException();
// }
// if (firstByte != (int)NbtTagType.Compound)
// {
// throw new NbtFormatException("Given NBT stream does not start with a TAG_Compound");
// }
// var rootCompound = new NbtCompound(reader.ReadString());
// rootCompound.ReadTag(reader);
// RootTag = rootCompound;
//}
}
void LoadFromStreamInternal([NotNull] Stream stream, [CanBeNull] TagSelector tagSelector)
{
// Make sure the first byte in this file is the tag for a TAG_Compound
if (FileVersion != NbtVersion.Legacy)
{
stream.Read(new byte[8], 0, 8);
}
int firstByte = stream.ReadByte();
if (firstByte < 0)
{
throw new EndOfStreamException();
}
if (firstByte != (int)NbtTagType.Compound)
{
throw new NbtFormatException("Given NBT stream does not start with a TAG_Compound");
}
var reader = new NbtBinaryReader(stream, BigEndian)
{
Selector = tagSelector,
UseVarInt = UseVarInt
};
var rootCompound = new NbtCompound(reader.ReadString());
rootCompound.ReadTag(reader);
RootTag = rootCompound;
}
/// <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 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>
/// タグ選択ダイアログ表示
/// </summary>
/// <param name="relativeControl"></param>
public void ShowTagSelector(FrameworkElement relativeControl)
{
switch (this.Client.SelectedPage.Value)
{
case PageType.Catalog:
if (this.SelectedItems.Count <= 0 && this.SelectedRecord.Value == null)
{
return;
}
break;
case PageType.Viewer:
if (this.SelectedRecord.Value == null)
{
return;
}
break;
default:
return;
}
var left
= (relativeControl != null) ? 10.0
: this.IsPaneOpen.Value ? (openPaneWidth + 10.0)
: 10.0;
var content = new TagSelector();
if (this.Client.SelectedPage.Value == PageType.Catalog && this.SelectedItems.Count > 1)
{
content.TagSelectedCallBack += x => this.SelectedItems.AddTag(x);
}
else if (this.SelectedRecord.Value != null)
{
content.Target = this.SelectedRecord.Value;
}
else
{
return;
}
this.PopupOwner.PopupDialog.Show(content,
new Thickness(left, double.NaN, double.NaN, double.NaN),
relativeControl == null ? HorizontalAlignment.Left : HorizontalAlignment.Right,
VerticalAlignment.Center, relativeControl);
}
/// <summary>
/// 获取标签
/// </summary>
/// <param name="accessToken"></param>
/// <param name="tagid"></param>
/// <returns></returns>
static List <TagSelector> GetTags(string accessToken, List <int> tagid)
{
if (tagid == null || tagid.Count == 0)
{
return(null);
}
Tags tags = new Tags();
Tags.Result result = tags.FindTagsCollection(accessToken);
if (result != null && result.errcode == 0)
{
var items = result.taglist.Where(e => tagid.Any(a => a == e.tagid)).ToList();
return(TagSelector.ConvertTo(items).ToList());
}
return(null);
}
public CityWeatherService(
ICityWeatherRepository repository,
IMapper mapper,
ILogger <CityWeatherService> logger,
ISettingService settingService)
{
_repository = repository;
_mapper = mapper;
_logger = logger;
_web = new HtmlWeb();
_parentNodeSelector = settingService.GetTagSelectorForCityWeatherParentNode();
_childTimeSelector = settingService.GetTagSelectorsForCityWeatherTime(_parentNodeSelector);
_childTemperatureSelector = settingService.GetTagSelectorsForCityWeatherDegree(_parentNodeSelector);
_tomorrowUrlPostfix = settingService.GetTomorrowUrlPostfix();
_minusControlChar = settingService.GetMinusControlChar();
}
public void GetSingleNodeTest()
{
var selector = new TagSelector
{
Tag = HtmlElementTag.Div,
Properties = new List <TagProperty>()
{
new TagProperty
{
Name = "class",
Value = "div4"
}
}
};
var result = HtmlParser.GetSingleNode(_htmlDocument.DocumentNode, selector);
Assert.NotNull(result);
Assert.Equal("<a href=\"http://url\"></a>", result.InnerHtml.Trim());
}
public IEnumerable <TagSelector> GetTagSelectorsForCityWeatherDegree(TagSelector parentNodeSelector)
{
return(new List <TagSelector>
{
parentNodeSelector,
new TagSelector
{
Tag = HtmlElementTag.Span,
Properties = new List <TagProperty>
{
new TagProperty
{
Name = "class",
Value = "unit unit_temperature_c"
}
}
}
});
}
/// <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(string fileName, NbtCompression compression, 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);
}
}
void LoadFromStreamInternal([NotNull] Stream stream, [CanBeNull] TagSelector tagSelector)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
// Make sure the first byte in this file is the tag for a TAG_Compound
if (stream.ReadByte() != (int)NbtTagType.Compound)
{
throw new NbtFormatException("Given NBT stream does not start with a TAG_Compound");
}
NbtBinaryReader reader = new NbtBinaryReader(stream, BigEndian)
{
Selector = tagSelector
};
var rootCompound = new NbtCompound(reader.ReadString());
rootCompound.ReadTag(reader);
RootTag = rootCompound;
}
void LoadFromStreamInternal(Stream stream, TagSelector tagSelector)
{
// Make sure the first byte in this file is the tag for a TAG_Compound
int firstByte = stream.ReadByte();
if (firstByte < 0)
{
throw new EndOfStreamException();
}
if (firstByte != (int)NbtTagType.Compound)
{
throw new NbtFormatException("Given NBT stream does not start with a TAG_Compound");
}
var reader = new NbtBinaryReader(stream, BigEndian)
{
Selector = tagSelector
};
var rootCompound = new NbtCompound(reader.ReadString());
rootCompound.ReadTag(reader);
RootTag = rootCompound;
}
public IEnumerable <TagSelector> GetTagSelectorsForCityWeatherTime(TagSelector parentNodeSelector)
{
return(new List <TagSelector>
{
parentNodeSelector,
new TagSelector
{
Tag = HtmlElementTag.Div,
Properties = new List <TagProperty>
{
new TagProperty
{
Name = "class",
Value = "w_time"
}
}
},
new TagSelector
{
Tag = HtmlElementTag.Span
}
});
}
/// <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 occured while parsing data in NBT format. </exception>
public int 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;
}
long startPosition = stream.Position;
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");
}
return((int)(stream.Position - startPosition));
}
public static HtmlNode GetSingleNode(HtmlNode htmlNode, TagSelector selector)
{
var expression = XpathExpressionBuilder.GetExpressionByTag(selector);
return(htmlNode.SelectSingleNode(expression));
}
/// <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(Stream stream, NbtCompression compression, 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(WrongZLibHeaderMessage);
}
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;
}
}
void LoadFromStreamInternal(Stream stream, TagSelector tagSelector)
{
// Make sure the first byte in this file is the tag for a TAG_Compound
int firstByte = stream.ReadByte();
if (firstByte < 0)
{
throw new EndOfStreamException();
}
if (firstByte != (int)NbtTagType.Compound)
{
throw new NbtFormatException("Given NBT stream does not start with a TAG_Compound");
}
var reader = new NbtBinaryReader(stream, BigEndian)
{
Selector = tagSelector
};
var rootCompound = new NbtCompound(reader.ReadString());
rootCompound.ReadTag(reader);
RootTag = rootCompound;
}
/// <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 or file version 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"/> or <paramref name="fileVersion"/> 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)
{
return(LoadFromStream(stream, compression, NbtVersion.AutoDetect, selector));
}
/// <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(string fileName, NbtCompression compression, 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 static string GetExpressionByTag(TagSelector elementTag)
{
return($"//{elementTag.Tag.ToString().ToLower()}{GetExpression(elementTag.Properties)}");
}
/// <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(WrongZLibHeaderMessage);
}
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);
}
}
/// <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(byte[] buffer, int index, int length, NbtCompression compression,
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;
}
}
