public void Deserialize(byte[] data, int len) { ReusableStream reader = new ReusableStream(data, 0, len, false); Channel = reader.ReadUInt16(); Part = reader.ReadUInt16(); TotalParts = reader.ReadUInt16(); Length = reader.ReadInt32(); ID = reader.ReadUInt16(); IsAsync = reader.ReadBoolean(); messageNum = reader.ReadUInt64(); force = reader.ReadBoolean(); int numOfItems = reader.ReadInt32(); for (int i = 0; i < numOfItems; ++i) { ulong key = reader.ReadUInt64(); int valueLen = reader.ReadInt32(); byte[] objData = new byte[valueLen]; reader.Read(objData, 0, valueLen); networkData.Data.Add(key, objData); } }
public void UninitializedStream() { var s = new ReusableStream(); Assert.Throws <NullReferenceException>(() => s.Write(true)); Assert.Throws <IndexOutOfRangeException>(() => s.ReadBoolean()); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { PlayerInfoSyncMessage t = new PlayerInfoSyncMessage(MessageTypes.PlayerInfoSync); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { CreateObjectRequestMessage t = new CreateObjectRequestMessage(MessageTypes.CreateObjectMessage); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { ClientRegisterResponseMessage t = new ClientRegisterResponseMessage(); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { GetCachedObjectsRequestMessage t = new GetCachedObjectsRequestMessage(MessageTypes.GetCachedObjectsMessage); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { AESMessage t = new AESMessage(); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { LoadSceneCompleteMessage t = new LoadSceneCompleteMessage(MessageTypes.LoadSceneCompleteMessage); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { RSARegistration t = new RSARegistration(); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public void Serialize(ReusableStream writer) { writer.Write(PublicKey.Length); writer.Write(PublicKey); writer.Write(Data.Length); writer.Write(Data); }
public void SetLength() { var s = new ReusableStream(16); Assert.AreEqual(0, s.Length); Assert.AreEqual(0, s.UnreadByteCount); Assert.AreEqual(16, s.Capacity); s.SetLength(4); Assert.AreEqual(4, s.Length); Assert.AreEqual(4, s.UnreadByteCount); Assert.AreEqual(16, s.Capacity); s.ReadInt32(); Assert.AreEqual(4, s.Length); Assert.AreEqual(0, s.UnreadByteCount); Assert.AreEqual(16, s.Capacity); s.SetLength(16); Assert.AreEqual(16, s.Length); Assert.AreEqual(12, s.UnreadByteCount); Assert.AreEqual(16, s.Capacity); s.SetLength(17); Assert.AreEqual(17, s.Length); Assert.AreEqual(13, s.UnreadByteCount); Assert.IsTrue(s.Capacity >= 17); s.SetLength(0); Assert.AreEqual(0, s.Length); Assert.AreEqual(0, s.UnreadByteCount); Assert.IsTrue(s.Capacity >= 17); Assert.Throws <ArgumentOutOfRangeException>(() => s.SetLength(-1)); }
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 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 T Deserialize <T>(ReusableStream reader) where T : IMessage { MessagePartConfirmation t = new MessagePartConfirmation(); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { FullSyncMessage t = new FullSyncMessage(MessageTypes.FullClientMessage); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
public T Deserialize <T>(ReusableStream reader) where T : IMessage { DestroyObjectsResponseMessage t = new DestroyObjectsResponseMessage(MessageTypes.DestroyObjectMessage); t.Deserialize(reader.Data, (int)reader.Length); return((T)(t as IMessage)); }
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(networkIDs.Count); for (int i = 0; i < networkIDs.Count; ++i) { writer.Write(networkIDs[i]); } }
public void Setup() { const int bufferLength = 64 * 1024; _ethalonBuffer = new Byte[bufferLength]; _ethalonStream = new MemoryStream(_ethalonBuffer); _testBuffer = new byte[bufferLength]; _testStream = new ReusableStream(_testBuffer); }
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); } }
private Stream Open(bool reuse) { var fileName = CreateFileName(); if (_journalStream == null || _journalStream.Disposed) { _journalStream = new ReusableStream(_settings.FileSystem.OpenAppend(fileName), reuse || _staticFileName); } return(_journalStream); }
public void VarInts() { var s = new ReusableStream(1000); var ints = new ulong[] { 17, 23, 0, 1, 2, 127, 128, 255, 256, (ulong)short.MaxValue, ushort.MaxValue, int.MaxValue, uint.MaxValue, long.MaxValue, ulong.MaxValue, 0x7FUL, 0x7FUL + 1, 0x3FFFUL, 0x3FFFUL + 1, 0x1FFFFFUL, 0x1FFFFFUL + 1, 0xFFFFFFFUL, 0xFFFFFFFUL + 1, 0x7FFFFFFFFUL, 0x7FFFFFFFFUL + 1, 0x3FFFFFFFFFFUL, 0x3FFFFFFFFFFUL + 1, 0x1FFFFFFFFFFFFUL, 0x1FFFFFFFFFFFFUL + 1, 0xFFFFFFFFFFFFFFUL, 0xFFFFFFFFFFFFFFUL + 1, 0x7FFFFFFFFFFFFFFFUL, 0x7FFFFFFFFFFFFFFFUL + 1, }; foreach (var ui in ints) { s.WriteVarUInt(ui); } s.ResetForReading(); foreach (var ui in ints) { var read = s.ReadVarUInt(); Assert.AreEqual(ui, read); } }
public static T Deserialize <T>(byte[] data, int len) where T : IMessage, new() { if (readStream == null) { readStream = new ReusableStream(); } readStream.ReplaceData(data, 0, len, false); if (MessageTypes.TryGetValue(typeof(T), out ISerialized sBase)) { return(sBase.Deserialize <T>(readStream)); } else if (typeof(T).GetInterfaces().Contains(typeof(ISerialized))) { sBase = (ISerialized) new T(); MessageTypes[typeof(T)] = sBase; return(sBase.Deserialize <T>(readStream)); } ushort channel = readStream.ReadUInt16(); ushort part = readStream.ReadUInt16(); ushort totalParts = readStream.ReadUInt16(); int length = readStream.ReadInt32(); ushort id = readStream.ReadUInt16(); bool isAsync = readStream.ReadBoolean(); T Mes; try { Mes = JsonUtility.FromJson <T>(readStream.ReadString()); Mes.Channel = channel; Mes.Part = part; Mes.TotalParts = totalParts; Mes.Length = length; Mes.ID = id; Mes.IsAsync = isAsync; } catch { Mes = new T { Channel = channel, Part = part, TotalParts = totalParts, Length = length, ID = id, IsAsync = isAsync }; } return(Mes); }
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 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 Deserialize(byte[] data, int len) { ReusableStream reader = new ReusableStream(data, 0, len, false); Channel = reader.ReadUInt16(); Part = reader.ReadUInt16(); TotalParts = reader.ReadUInt16(); Length = reader.ReadInt32(); ID = reader.ReadUInt16(); IsAsync = reader.ReadBoolean(); SceneName = reader.ReadString(); }
public void StringEncodingLengths() { var s = new ReusableStream(100); var expectedLength = 0; var strings = new[] { "a", "瀬", "𐐷", }; var encodings = new[] { Encoding.ASCII, Encoding.UTF7, Encoding.UTF8, Encoding.Unicode, Encoding.BigEndianUnicode, Encoding.UTF32, }; foreach (var str in strings) { foreach (var e in encodings) { s.WriteString(str, false, e); expectedLength += e.GetByteCount(str) + 1; Assert.AreEqual(expectedLength, s.Length); } } s.ResetForReading(); foreach (var str in strings) { foreach (var e in encodings) { var read = s.ReadString(false, e); if (e == Encoding.ASCII) { continue; } Assert.AreEqual(str, read); } } }
public void Deserialize(byte[] data, int len) { ReusableStream reader = new ReusableStream(data, 0, len, false); Channel = reader.ReadUInt16(); Part = reader.ReadUInt16(); TotalParts = reader.ReadUInt16(); Length = reader.ReadInt32(); ID = reader.ReadUInt16(); IsAsync = reader.ReadBoolean(); playerRequested = reader.ReadInt32(); networkID = reader.ReadUInt64(); }