public void Serialize(ReusableStream writer)
{
writer.Write(PublicKey.Length);
writer.Write(PublicKey);
writer.Write(Data.Length);
writer.Write(Data);
}
public void Serialize(ReusableStream writer)
{
writer.Write(networkIDs.Count);
for (int i = 0; i < networkIDs.Count; ++i)
{
writer.Write(networkIDs[i]);
}
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerRequested);
writer.Write(playerToOwn);
writer.Write(prefabName);
writer.Write((int)spawnType);
writer.Write(perminant);
}
public void Serialize(ReusableStream writer)
{
writer.Write(owner);
writer.Write(networkedObjectData.Length);
writer.Write(networkedObjectData);
writer.Write(prefabName);
writer.Write((int)spawnType);
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerInfo.Count);
foreach (var mapping in playerInfo)
{
writer.Write(mapping.Key);
writer.Write(mapping.Value.PlayerID);
writer.Write(mapping.Value.PlayerName);
writer.Write(mapping.Value.PlayerPing);
}
}
public void Serialize(ReusableStream writer)
{
writer.Write(sceneName);
writer.Write(sceneMapping.Count);
foreach (var mapping in sceneMapping)
{
writer.Write(mapping.Key);
writer.Write(mapping.Value.Length);
writer.Write(mapping.Value);
}
}
public void CanGrow()
{
var s = new ReusableStream(8, true);
Assert.AreEqual(8, s.Capacity);
s.Write((long)3);
// there shouldn't be any change yet
Assert.AreEqual(8, s.Capacity);
s.Write(4);
Assert.IsTrue(s.Capacity >= 12);
}
public void CanGrowDisabled()
{
var s = new ReusableStream(8, false);
Assert.AreEqual(8, s.Capacity);
s.Write((long)3);
// there shouldn't be any change
Assert.AreEqual(8, s.Capacity);
Assert.Throws <IndexOutOfRangeException>(() => s.Write(4));
// there shouldn't be any change
Assert.AreEqual(8, s.Capacity);
}
public void UninitializedStream()
{
var s = new ReusableStream();
Assert.Throws <NullReferenceException>(() => s.Write(true));
Assert.Throws <IndexOutOfRangeException>(() => s.ReadBoolean());
}
public void Resetting()
{
var s = new ReusableStream(16);
Assert.AreEqual(0, s.Position);
Assert.AreEqual(0, s.Length);
var written = long.MaxValue;
s.Write(written);
Assert.AreEqual(8, s.Position);
Assert.AreEqual(8, s.Length);
s.ResetForReading();
Assert.AreEqual(0, s.Position);
Assert.AreEqual(8, s.Length);
var read = s.ReadInt64();
Assert.AreEqual(written, read);
Assert.AreEqual(8, s.Position);
Assert.AreEqual(8, s.Length);
s.ResetForWriting();
Assert.AreEqual(0, s.Position);
Assert.AreEqual(0, s.Length);
written = 1;
s.Write(written);
Assert.AreEqual(8, s.Position);
Assert.AreEqual(8, s.Length);
s.ResetForReading();
Assert.AreEqual(0, s.Position);
Assert.AreEqual(8, s.Length);
read = s.ReadInt64();
Assert.AreEqual(written, read);
Assert.AreEqual(8, s.Position);
Assert.AreEqual(8, s.Length);
}
public static byte[] Serialize <T>(ref T message) where T : IMessage
{
if (writeStream == null)
{
writeStream = new ReusableStream(new byte[64512], 0, 64512, true);
}
writeStream.ResetForReading();
writeStream.Write(message.Channel);
writeStream.Write(message.Part);
writeStream.Write(message.TotalParts);
writeStream.Write(message.Length);
writeStream.Write(message.ID);
writeStream.Write(message.IsAsync);
if (message is ISerialized sMessage)
{
sMessage.Serialize(writeStream);
}
else
{
writeStream.Write(JsonUtility.ToJson(message));
}
return(writeStream.Data.SubArray(0, (int)writeStream.Position));
}
public static void Serialize <T>(ref T message, byte[] buffer, out int len) where T : IMessage
{
if (reusableStream == null)
{
reusableStream = new ReusableStream();
}
reusableStream.ReplaceData(buffer, 0, buffer.Length, false);
reusableStream.Write(message.Channel);
reusableStream.Write(message.Part);
reusableStream.Write(message.TotalParts);
reusableStream.Write(message.Length);
reusableStream.Write(message.ID);
reusableStream.Write(message.IsAsync);
if (message is ISerialized sMessage)
{
sMessage.Serialize(reusableStream);
}
else
{
reusableStream.Write(JsonUtility.ToJson(message));
}
len = (int)reusableStream.Position;
}
public void Serialize(ReusableStream writer)
{
writer.Write(messageNum);
writer.Write(force);
writer.Write(networkData.Data.Count);
foreach (KeyValuePair <ulong, byte[]> pair in networkData.Data)
{
writer.Write(pair.Key);
writer.Write(pair.Value.Length);
writer.Write(pair.Value);
}
}
public unsafe void ReadPastEnd()
{
var s = new ReusableStream(16);
s.Write((ulong)3);
var buffer = new byte[16];
fixed(byte *p = buffer)
{
var bufferPtr = p;
Assert.AreEqual(-1, s.ReadByte());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadBoolean());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadInt8());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadUInt8());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadInt16());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadUInt16());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadInt32());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadUInt32());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadInt64());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadUInt64());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadSingle());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadDouble());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadDateTime());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadGuid());
Assert.Throws <IndexOutOfRangeException>(() => s.ReadString(true));
Assert.AreEqual(0, s.Read(buffer, 0, 1));
Assert.AreEqual(0, s.Read(bufferPtr, 1));
s.ResetForReading();
Assert.AreEqual(8, s.Read(buffer, 0, 9));
s.ResetForReading();
Assert.AreEqual(8, s.Read(bufferPtr, 9));
}
}
public void Serialize(ReusableStream writer)
{
writer.Write(SceneName);
}
public void Serialize(ReusableStream writer)
{
writer.Write(owner);
}
public void Serialize(ReusableStream writer)
{
writer.Write(Accepted);
writer.Write(PlayerID);
writer.Write(playerName);
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerName);
}
public void Serialize(ReusableStream writer)
{
writer.Write(message.Length);
writer.Write(message);
}
public void Serialize(ReusableStream writer)
{
writer.Write(MessageID);
writer.Write(PartNumber);
}
public void Serialize(ReusableStream writer)
{
writer.Write((byte)step);
writer.Write(Data.Length);
writer.Write(Data);
}
public unsafe void ReadWriteBytes()
{
var s = new ReusableStream(4000);
var rng = new Random();
var tests = new byte[][]
{
new byte[1],
new byte[2],
new byte[3],
new byte[4],
new byte[5],
new byte[6],
new byte[7],
new byte[8],
new byte[9],
new byte[10],
new byte[11],
new byte[12],
new byte[13],
new byte[14],
new byte[15],
new byte[16],
new byte[17],
new byte[127],
new byte[128],
new byte[129],
new byte[255],
new byte[256],
new byte[257],
new byte[400],
new byte[800],
new byte[1200],
};
var expectedLength = 0;
foreach (var test in tests)
{
rng.NextBytes(test);
s.Write(test);
expectedLength += test.Length;
Assert.AreEqual(expectedLength, s.Length);
}
s.ResetForReading();
foreach (var test in tests)
{
var read = new byte[test.Length];
s.Read(read, 0, read.Length);
AssertBytesAreEqual(test, read);
}
// do the same thing using the unsafe methods now
s = new ReusableStream(4000);
expectedLength = 0;
foreach (var test in tests)
{
fixed(byte *ptr = test)
{
s.Write(ptr, test.Length);
}
expectedLength += test.Length;
Assert.AreEqual(expectedLength, s.Length);
}
s.ResetForReading();
foreach (var test in tests)
{
var read = new byte[test.Length + 16];
fixed(byte *ptr = read)
{
const ulong GUARD = 0xAAAAAAAAAAAAAAAA;
var startGuard = (ulong *)ptr;
var data = &ptr[8];
var endGuard = (ulong *)&data[test.Length];
*startGuard = GUARD;
*endGuard = GUARD;
s.Read(data, test.Length);
Assert.AreEqual(GUARD, *startGuard);
Assert.AreEqual(GUARD, *endGuard);
}
var actual = new byte[test.Length];
Array.Copy(read, 8, actual, 0, test.Length);
AssertBytesAreEqual(test, actual);
}
}
public void Serialize(ReusableStream writer)
{
writer.Write(playerRequested);
writer.Write(networkID);
}
public void ReadWritePrimitives()
{
var s = new ReusableStream(100);
var rng = new Random();
var b = (byte)rng.Next(255);
var sb = (sbyte)rng.Next(255);
var sh = (short)rng.Next(short.MinValue, short.MaxValue);
var ush = (ushort)rng.Next(ushort.MaxValue);
var i = rng.Next(int.MinValue, int.MaxValue);
var ui = (uint)rng.Next(int.MinValue, int.MaxValue);
var l = (long)RandomULong(rng);
var ul = RandomULong(rng);
var f = (float)rng.NextDouble();
var d = rng.NextDouble();
var c = (char)rng.Next(char.MinValue, char.MaxValue);
var t = DateTime.UtcNow;
var g = Guid.NewGuid();
var expectedLength = 0;
s.Write(b);
expectedLength += 1;
Assert.AreEqual(expectedLength, s.Length);
s.Write(sb);
expectedLength += 1;
Assert.AreEqual(expectedLength, s.Length);
s.Write(sh);
expectedLength += 2;
Assert.AreEqual(expectedLength, s.Length);
s.Write(ush);
expectedLength += 2;
Assert.AreEqual(expectedLength, s.Length);
s.Write(i);
expectedLength += 4;
Assert.AreEqual(expectedLength, s.Length);
s.Write(ui);
expectedLength += 4;
Assert.AreEqual(expectedLength, s.Length);
s.Write(l);
expectedLength += 8;
Assert.AreEqual(expectedLength, s.Length);
s.Write(ul);
expectedLength += 8;
Assert.AreEqual(expectedLength, s.Length);
s.Write(f);
expectedLength += 4;
Assert.AreEqual(expectedLength, s.Length);
s.Write(d);
expectedLength += 8;
Assert.AreEqual(expectedLength, s.Length);
s.Write(c);
expectedLength += 2;
Assert.AreEqual(expectedLength, s.Length);
s.Write(false);
expectedLength += 1;
Assert.AreEqual(expectedLength, s.Length);
s.Write(true);
expectedLength += 1;
Assert.AreEqual(expectedLength, s.Length);
s.Write(t);
expectedLength += 8;
Assert.AreEqual(expectedLength, s.Length);
s.Write(g);
expectedLength += 16;
Assert.AreEqual(expectedLength, s.Length);
s.ResetForReading();
Assert.AreEqual(b, s.ReadUInt8());
Assert.AreEqual(sb, s.ReadInt8());
Assert.AreEqual(sh, s.ReadInt16());
Assert.AreEqual(ush, s.ReadUInt16());
Assert.AreEqual(i, s.ReadInt32());
Assert.AreEqual(ui, s.ReadUInt32());
Assert.AreEqual(l, s.ReadInt64());
Assert.AreEqual(ul, s.ReadUInt64());
Assert.AreEqual(f, s.ReadSingle());
Assert.AreEqual(d, s.ReadDouble());
Assert.AreEqual(c, s.ReadChar());
Assert.AreEqual(false, s.ReadBoolean());
Assert.AreEqual(true, s.ReadBoolean());
Assert.AreEqual(t, s.ReadDateTime());
Assert.AreEqual(g, s.ReadGuid());
// verify that we read to the end
Assert.AreEqual(s.Length, s.Position);
s.ResetForReading();
Assert.AreEqual((int)b, s.ReadByte());
}
public void Serialize(ReusableStream writer)
{
writer.Write(LastKnownFTT);
}