/// <summary> Creates a copy of given NbtByte tag. </summary>
/// <param name="other"> Tag to copy. May not be <c>null</c>. </param>
/// <exception cref="ArgumentNullException"> <paramref name="other"/> is <c>null</c>. </exception>
public NbtByte([NotNull] NbtByte other)
{
if (other == null)
{
throw new ArgumentNullException("other");
}
name = other.name;
Value = other.Value;
}
internal override void SkipTag(NbtBinaryReader readStream)
{
while (true)
{
NbtTagType nextTag = readStream.ReadTagType();
NbtTag newTag;
switch (nextTag)
{
case NbtTagType.End:
return;
case NbtTagType.Byte:
newTag = new NbtByte();
break;
case NbtTagType.Short:
newTag = new NbtShort();
break;
case NbtTagType.Int:
newTag = new NbtInt();
break;
case NbtTagType.Long:
newTag = new NbtLong();
break;
case NbtTagType.Float:
newTag = new NbtFloat();
break;
case NbtTagType.Double:
newTag = new NbtDouble();
break;
case NbtTagType.ByteArray:
newTag = new NbtByteArray();
break;
case NbtTagType.String:
newTag = new NbtString();
break;
case NbtTagType.List:
newTag = new NbtList();
break;
case NbtTagType.Compound:
newTag = new NbtCompound();
break;
case NbtTagType.IntArray:
newTag = new NbtIntArray();
break;
default:
throw new NbtFormatException("Unsupported tag type found in NBT_Compound: " + nextTag);
}
readStream.SkipString();
newTag.SkipTag(readStream);
}
}
public void GettersAndSetters()
{
// construct a document for us to test.
var nestedChild = new NbtCompound("NestedChild");
var nestedInt = new NbtInt(1);
var nestedChildList = new NbtList("NestedChildList")
{
nestedInt
};
var child = new NbtCompound("Child")
{
nestedChild,
nestedChildList
};
var childList = new NbtList("ChildList")
{
new NbtInt(1)
};
var parent = new NbtCompound("Parent")
{
child,
childList
};
// Accessing nested compound tags using indexers
Assert.Equal(nestedChild, parent["Child"]["NestedChild"]);
Assert.Equal(nestedChildList, parent["Child"]["NestedChildList"]);
Assert.Equal(nestedInt, parent["Child"]["NestedChildList"][0]);
// Accessing nested compound tags using Get and Get<T>
Assert.Throws<ArgumentNullException>(() => parent.Get<NbtCompound>(null));
Assert.Null(parent.Get<NbtCompound>("NonExistingChild"));
Assert.Equal(nestedChild, parent.Get<NbtCompound>("Child").Get<NbtCompound>("NestedChild"));
Assert.Equal(nestedChildList, parent.Get<NbtCompound>("Child").Get<NbtList>("NestedChildList"));
Assert.Equal(nestedInt, parent.Get<NbtCompound>("Child").Get<NbtList>("NestedChildList")[0]);
Assert.Throws<ArgumentNullException>(() => parent.Get(null));
Assert.Null(parent.Get("NonExistingChild"));
Assert.Equal(nestedChild, (parent.Get("Child") as NbtCompound).Get("NestedChild"));
Assert.Equal(nestedChildList, (parent.Get("Child") as NbtCompound).Get("NestedChildList"));
Assert.Equal(nestedInt, (parent.Get("Child") as NbtCompound).Get("NestedChildList")[0]);
// Accessing with Get<T> and an invalid given type
Assert.Throws<InvalidCastException>(() => parent.Get<NbtInt>("Child"));
// Using TryGet and TryGet<T>
NbtTag dummyTag;
Assert.Throws<ArgumentNullException>(() => parent.TryGet(null, out dummyTag));
Assert.False(parent.TryGet("NonExistingChild", out dummyTag));
Assert.True(parent.TryGet("Child", out dummyTag));
NbtCompound dummyCompoundTag;
Assert.Throws<ArgumentNullException>(() => parent.TryGet(null, out dummyCompoundTag));
Assert.False(parent.TryGet("NonExistingChild", out dummyCompoundTag));
Assert.True(parent.TryGet("Child", out dummyCompoundTag));
// Trying to use integer indexers on non-NbtList tags
Assert.Throws<InvalidOperationException>(() => parent[0] = nestedInt);
Assert.Throws<InvalidOperationException>(() => nestedInt[0] = nestedInt);
// Trying to use string indexers on non-NbtCompound tags
Assert.Throws<InvalidOperationException>(() => childList["test"] = nestedInt);
Assert.Throws<InvalidOperationException>(() => nestedInt["test"] = nestedInt);
// Trying to get a non-existent element by name
Assert.Null(parent.Get<NbtTag>("NonExistentTag"));
Assert.Null(parent["NonExistentTag"]);
// Null indices on NbtCompound
Assert.Throws<ArgumentNullException>(() => parent.Get<NbtTag>(null));
Assert.Throws<ArgumentNullException>(() => parent[null] = new NbtInt(1));
Assert.Throws<ArgumentNullException>(() => nestedInt = (NbtInt) parent[null]);
// Out-of-range indices on NbtList
Assert.Throws<ArgumentOutOfRangeException>(() => nestedInt = (NbtInt) childList[-1]);
Assert.Throws<ArgumentOutOfRangeException>(() => childList[-1] = new NbtInt(1));
Assert.Throws<ArgumentOutOfRangeException>(() => nestedInt = childList.Get<NbtInt>(-1));
Assert.Throws<ArgumentOutOfRangeException>(() => nestedInt = (NbtInt) childList[childList.Count]);
Assert.Throws<ArgumentOutOfRangeException>(() => nestedInt = childList.Get<NbtInt>(childList.Count));
// Using setter correctly
parent["NewChild"] = new NbtByte("NewChild");
// Using setter incorrectly
object dummyObject;
Assert.Throws<ArgumentNullException>(() => parent["Child"] = null);
Assert.NotNull(parent["Child"]);
Assert.Throws<ArgumentException>(() => parent["Child"] = new NbtByte("NotChild"));
Assert.Throws<InvalidOperationException>(() => dummyObject = parent[0]);
Assert.Throws<InvalidOperationException>(() => parent[0] = new NbtByte("NewerChild"));
// Try adding tag to self
var selfTest = new NbtCompound("SelfTest");
Assert.Throws<ArgumentException>(() => selfTest["SelfTest"] = selfTest);
// Try adding a tag that already has a parent
Assert.Throws<ArgumentException>(() => selfTest[child.Name] = child);
}
internal override bool ReadTag(NbtBinaryReader readStream)
{
if (Parent != null && readStream.Selector != null && !readStream.Selector(this))
{
SkipTag(readStream);
return(false);
}
while (true)
{
NbtTagType nextTag = readStream.ReadTagType();
NbtTag newTag;
switch (nextTag)
{
case NbtTagType.End:
return(true);
case NbtTagType.Byte:
newTag = new NbtByte();
break;
case NbtTagType.Short:
newTag = new NbtShort();
break;
case NbtTagType.Int:
newTag = new NbtInt();
break;
case NbtTagType.Long:
newTag = new NbtLong();
break;
case NbtTagType.Float:
newTag = new NbtFloat();
break;
case NbtTagType.Double:
newTag = new NbtDouble();
break;
case NbtTagType.ByteArray:
newTag = new NbtByteArray();
break;
case NbtTagType.String:
newTag = new NbtString();
break;
case NbtTagType.List:
newTag = new NbtList();
break;
case NbtTagType.Compound:
newTag = new NbtCompound();
break;
case NbtTagType.IntArray:
newTag = new NbtIntArray();
break;
default:
throw new NbtFormatException("Unsupported tag type found in NBT_Compound: " + nextTag);
}
newTag.Parent = this;
newTag.Name = readStream.ReadString();
if (newTag.ReadTag(readStream))
{
// ReSharper disable AssignNullToNotNullAttribute
// newTag.Name is never null
tags.Add(newTag.Name, newTag);
// ReSharper restore AssignNullToNotNullAttribute
}
}
}
internal override bool ReadTag(NbtBinaryReader readStream)
{
if (readStream.Selector != null && !readStream.Selector(this))
{
SkipTag(readStream);
return(false);
}
ListType = readStream.ReadTagType();
int length = readStream.ReadInt32();
if (length < 0)
{
throw new NbtFormatException("Negative list size given.");
}
for (int i = 0; i < length; i++)
{
NbtTag newTag;
switch (ListType)
{
case NbtTagType.Byte:
newTag = new NbtByte();
break;
case NbtTagType.Short:
newTag = new NbtShort();
break;
case NbtTagType.Int:
newTag = new NbtInt();
break;
case NbtTagType.Long:
newTag = new NbtLong();
break;
case NbtTagType.Float:
newTag = new NbtFloat();
break;
case NbtTagType.Double:
newTag = new NbtDouble();
break;
case NbtTagType.ByteArray:
newTag = new NbtByteArray();
break;
case NbtTagType.String:
newTag = new NbtString();
break;
case NbtTagType.List:
newTag = new NbtList();
break;
case NbtTagType.Compound:
newTag = new NbtCompound();
break;
case NbtTagType.IntArray:
newTag = new NbtIntArray();
break;
default:
// should never happen, since ListType is checked beforehand
throw new NbtFormatException("Unsupported tag type found in a list: " + ListType);
}
newTag.Parent = this;
if (newTag.ReadTag(readStream))
{
tags.Add(newTag);
}
}
return(true);
}
