warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Updates Serialization (#292)

Browse source 
- [X] Removes all save strategies
- [X] Removes duplicate file writer that won't be used
- [X] Removes persistence (it will become a duplicate system)
- [X] Add a save position variable to skip serializing a clean item/mobile
- [X] Update Guilds/Accounts to be IEntity types
    - Because guilds are abstract, this may make serialization tricky.
- [X] Update the generalized IEntity writing
- [X] Update the load/save to write to buffers then to files in background


Bumps release version
This commit is contained in:
Kamron Batman 2020-10-31 17:38:29 -07:00 • committed by GitHub
parent a8d486a969
commit 1ca8655fc1
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
43 changed files with 1148 additions and 4351 deletions
Download patch file Download diff file Expand all files Collapse all files

718
Projects/Server/Serialization/AsyncWriter.cs
View file

@ -1,718 +0,0 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: AsyncWriter.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation, either version 3 of the License, or *
* (at your option) any later version. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Threading;
using Server.Guilds;
namespace Server
{
public sealed class AsyncWriter : IGenericWriter
{
private readonly int m_BufferSize;
private readonly FileStream m_File;
private readonly bool m_PrefixStrings;
private readonly Queue<MemoryStream> m_WriteQueue;
private BinaryWriter m_Bin;
private bool m_Closed;
private long m_LastPos;
private MemoryStream m_Mem;
private Thread m_WorkerThread;
public AsyncWriter(string filename, bool prefix)
: this(filename, 1048576, prefix) // 1 mb buffer
{
}
public AsyncWriter(string filename, int buffSize, bool prefix)
{
m_PrefixStrings = prefix;
m_Closed = false;
m_WriteQueue = new Queue<MemoryStream>();
m_BufferSize = buffSize;
m_File = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None);
m_Mem = new MemoryStream(m_BufferSize + 1024);
m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
}
public static int ThreadCount { get; private set; }
public MemoryStream MemStream
{
get => m_Mem;
set
{
if (m_Mem.Length > 0)
{
Enqueue(m_Mem);
}
m_Mem = value;
m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
m_LastPos = 0;
Position = m_Mem.Length;
m_Mem.Seek(0, SeekOrigin.End);
}
}
public long Position { get; private set; }
public void Close()
{
Enqueue(m_Mem);
m_Closed = true;
}
public void Write(IPAddress value)
{
m_Bin.Write(Utility.GetLongAddressValue(value));
OnWrite();
}
public void Write(string value)
{
if (m_PrefixStrings)
{
if (value == null)
{
m_Bin.Write((byte)0);
}
else
{
m_Bin.Write((byte)1);
m_Bin.Write(value);
}
}
else
{
m_Bin.Write(value);
}
OnWrite();
}
public void WriteDeltaTime(DateTime value)
{
var ticks = value.Ticks;
var now = DateTime.UtcNow.Ticks;
TimeSpan d;
try
{
d = new TimeSpan(ticks - now);
}
catch
{
d = TimeSpan.MaxValue;
}
Write(d);
}
public void Write(DateTime value)
{
m_Bin.Write(value.Ticks);
OnWrite();
}
public void Write(DateTimeOffset value)
{
m_Bin.Write(value.Ticks);
m_Bin.Write(value.Offset.Ticks);
OnWrite();
}
public void Write(TimeSpan value)
{
m_Bin.Write(value.Ticks);
OnWrite();
}
public void Write(decimal value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(long value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(ulong value)
{
m_Bin.Write(value);
OnWrite();
}
public void WriteEncodedInt(int value)
{
var v = (uint)value;
while (v >= 0x80)
{
m_Bin.Write((byte)(v | 0x80));
v >>= 7;
}
m_Bin.Write((byte)v);
OnWrite();
}
public void Write(int value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(uint value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(short value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(ushort value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(double value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(float value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(char value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(byte value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(byte[] value)
{
Write(value, value.Length);
}
public void Write(byte[] value, int length)
{
m_Bin.Write(value, 0, length);
OnWrite();
}
public void Write(sbyte value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(bool value)
{
m_Bin.Write(value);
OnWrite();
}
public void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
public void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
public void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
public void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
public void Write(Map value)
{
if (value != null)
{
Write((byte)value.MapIndex);
}
else
{
Write((byte)0xFF);
}
}
public void Write(Race value)
{
if (value != null)
{
Write((byte)value.RaceIndex);
}
else
{
Write((byte)0xFF);
}
}
public void WriteEntity(IEntity value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(Item value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(Mobile value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(BaseGuild value)
{
if (value == null)
{
Write(0);
}
else
{
Write(value.Serial);
}
}
public void WriteItem<T>(T value) where T : Item
{
Write(value);
}
public void WriteMobile<T>(T value) where T : Mobile
{
Write(value);
}
public void WriteGuild<T>(T value) where T : BaseGuild
{
Write(value);
}
public void Write(List<Item> list)
{
WriteItemList(list);
}
public void Write(List<Item> list, bool tidy)
{
WriteItemList(list, tidy);
}
public void WriteItemList<T>(List<T> list) where T : Item
{
WriteItemList(list, false);
}
public void WriteItemList<T>(List<T> list, bool tidy) where T : Item
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Deleted)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<Item> set)
{
Write(set, false);
}
public void Write(HashSet<Item> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(item => item.Deleted);
}
Write(set.Count);
foreach (var item in set)
{
Write(item);
}
}
public void WriteItemSet<T>(HashSet<T> set) where T : Item
{
WriteItemSet(set, false);
}
public void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item
{
if (tidy)
{
set.RemoveWhere(item => item.Deleted);
}
Write(set.Count);
foreach (var item in set)
{
Write(item);
}
}
public void Write(List<Mobile> list)
{
Write(list, false);
}
public void Write(List<Mobile> list, bool tidy)
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Deleted)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void WriteMobileList<T>(List<T> list) where T : Mobile
{
WriteMobileList(list, false);
}
public void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Deleted)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<Mobile> set)
{
Write(set, false);
}
public void Write(HashSet<Mobile> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(mobile => mobile.Deleted);
}
Write(set.Count);
foreach (var mob in set)
{
Write(mob);
}
}
public void WriteMobileSet<T>(HashSet<T> set) where T : Mobile
{
WriteMobileSet(set, false);
}
public void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile
{
if (tidy)
{
set.RemoveWhere(mob => mob.Deleted);
}
Write(set.Count);
foreach (var mob in set)
{
Write(mob);
}
}
public void Write(List<BaseGuild> list)
{
Write(list, false);
}
public void Write(List<BaseGuild> list, bool tidy)
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Disbanded)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void WriteGuildList<T>(List<T> list) where T : BaseGuild
{
WriteGuildList(list, false);
}
public void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Disbanded)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<BaseGuild> set)
{
Write(set, false);
}
public void Write(HashSet<BaseGuild> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(guild => guild.Disbanded);
}
Write(set.Count);
foreach (var guild in set)
{
Write(guild);
}
}
public void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild
{
WriteGuildSet(set, false);
}
public void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild
{
if (tidy)
{
set.RemoveWhere(guild => guild.Disbanded);
}
Write(set.Count);
foreach (var guild in set)
{
Write(guild);
}
}
private void Enqueue(MemoryStream mem)
{
lock (m_WriteQueue)
{
m_WriteQueue.Enqueue(mem);
}
if (m_WorkerThread.IsAlive != true)
{
m_WorkerThread = new Thread(new WorkerThread(this).Worker) { Priority = ThreadPriority.BelowNormal };
m_WorkerThread.Start();
}
}
private void OnWrite()
{
var curlen = m_Mem.Length;
Position += curlen - m_LastPos;
m_LastPos = curlen;
if (curlen >= m_BufferSize)
{
Enqueue(m_Mem);
m_Mem = new MemoryStream(m_BufferSize + 1024);
m_Bin = new BinaryWriter(m_Mem, Utility.UTF8WithEncoding);
m_LastPos = 0;
}
}
private class WorkerThread
{
private readonly AsyncWriter m_Owner;
public WorkerThread(AsyncWriter owner) => m_Owner = owner;
public void Worker()
{
ThreadCount++;
int lastCount;
do
{
MemoryStream mem = null;
lock (m_Owner.m_WriteQueue)
{
if ((lastCount = m_Owner.m_WriteQueue.Count) > 0)
{
mem = m_Owner.m_WriteQueue.Dequeue();
}
}
if (mem?.Length > 0)
{
mem.WriteTo(m_Owner.m_File);
}
} while (lastCount > 1);
if (m_Owner.m_Closed)
{
m_Owner.m_File.Close();
}
ThreadCount--;
if (ThreadCount <= 0)
{
World.NotifyDiskWriteComplete();
}
}
}
}
}

2
Projects/Server/Serialization/BinaryFileReader.cs
View file

@ -131,7 +131,7 @@ namespace Server
public Mobile ReadMobile() => World.FindMobile(ReadUInt());
public BaseGuild ReadGuild() => BaseGuild.Find(ReadUInt());
public BaseGuild ReadGuild() => World.FindGuild(ReadUInt());
public T ReadItem<T>() where T : Item => ReadItem() as T;

792
Projects/Server/Serialization/BinaryFileWriter.cs
View file

@ -2,7 +2,7 @@
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: BinaryFileWriter.cs *
* File: BufferedFileWriter.cs *
* *
* This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
@ -13,751 +13,23 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Text;
using Server.Guilds;
namespace Server
{
public class BinaryFileWriter : IGenericWriter
public class BinaryFileWriter : BufferWriter
{
private const int LargeByteBufferSize = 256;
private readonly byte[] m_Buffer;
private readonly Encoding m_Encoding;
private readonly Stream m_File;
private readonly bool m_PrefixStrings;
private readonly char[] m_SingleCharBuffer = new char[1];
private byte[] m_CharacterBuffer;
private int m_Index;
private int m_MaxBufferChars;
private long m_Position;
public BinaryFileWriter(Stream strm, bool prefixStr)
{
m_PrefixStrings = prefixStr;
m_Encoding = Utility.UTF8;
m_Buffer = new byte[BufferSize];
m_File = strm;
}
public BinaryFileWriter(string filename, bool prefixStr)
{
m_PrefixStrings = prefixStr;
m_Buffer = new byte[BufferSize];
public BinaryFileWriter(string filename, bool prefixStr) : base(prefixStr) =>
m_File = new FileStream(filename, FileMode.Create, FileAccess.Write, FileShare.None);
m_Encoding = Utility.UTF8WithEncoding;
}
protected virtual int BufferSize => 64 * 1024;
public BinaryFileWriter(Stream stream, bool prefixStr) : base(prefixStr) => m_File = stream;
public Stream UnderlyingStream
{
get
{
if (m_Index > 0)
{
Flush();
}
return m_File;
}
}
protected override int BufferSize => 512;
public long Position => m_Position + m_Index;
public void Close()
{
if (m_Index > 0)
{
Flush();
}
m_File.Close();
}
public void WriteEncodedInt(int value)
{
var v = (uint)value;
while (v >= 0x80)
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = (byte)(v | 0x80);
v >>= 7;
}
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = (byte)v;
}
public void Write(string value)
{
if (m_PrefixStrings)
{
if (value == null)
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = 0;
}
else
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = 1;
InternalWriteString(value);
}
}
else
{
InternalWriteString(value);
}
}
public void Write(DateTime value)
{
Write(value.Ticks);
}
public void Write(DateTimeOffset value)
{
Write(value.Ticks);
Write(value.Offset.Ticks);
}
public void WriteDeltaTime(DateTime value)
{
var ticks = value.Ticks;
var now = DateTime.UtcNow.Ticks;
TimeSpan d;
try
{
d = new TimeSpan(ticks - now);
}
catch
{
d = TimeSpan.MaxValue;
}
Write(d);
}
public void Write(IPAddress value)
{
Write(Utility.GetLongAddressValue(value));
}
public void Write(TimeSpan value)
{
Write(value.Ticks);
}
public void Write(decimal value)
{
var bits = decimal.GetBits(value);
for (var i = 0; i < bits.Length; ++i)
{
Write(bits[i]);
}
}
public void Write(long value)
{
if (m_Index + 8 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index + 4] = (byte)(value >> 32);
m_Buffer[m_Index + 5] = (byte)(value >> 40);
m_Buffer[m_Index + 6] = (byte)(value >> 48);
m_Buffer[m_Index + 7] = (byte)(value >> 56);
m_Index += 8;
}
public void Write(ulong value)
{
if (m_Index + 8 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index + 4] = (byte)(value >> 32);
m_Buffer[m_Index + 5] = (byte)(value >> 40);
m_Buffer[m_Index + 6] = (byte)(value >> 48);
m_Buffer[m_Index + 7] = (byte)(value >> 56);
m_Index += 8;
}
public void Write(int value)
{
if (m_Index + 4 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Index += 4;
}
public void Write(uint value)
{
if (m_Index + 4 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Index += 4;
}
public void Write(short value)
{
if (m_Index + 2 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Index += 2;
}
public void Write(ushort value)
{
if (m_Index + 2 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Index += 2;
}
public unsafe void Write(double value)
{
if (m_Index + 8 > m_Buffer.Length)
{
Flush();
}
fixed (byte* pBuffer = m_Buffer)
{
*(double*)(pBuffer + m_Index) = value;
}
m_Index += 8;
}
public unsafe void Write(float value)
{
if (m_Index + 4 > m_Buffer.Length)
{
Flush();
}
fixed (byte* pBuffer = m_Buffer)
{
*(float*)(pBuffer + m_Index) = value;
}
m_Index += 4;
}
public void Write(char value)
{
if (m_Index + 8 > m_Buffer.Length)
{
Flush();
}
m_SingleCharBuffer[0] = value;
var byteCount = m_Encoding.GetBytes(m_SingleCharBuffer, 0, 1, m_Buffer, m_Index);
m_Index += byteCount;
}
public void Write(byte value)
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = value;
}
public void Write(byte[] value)
{
Write(value, value.Length);
}
public void Write(byte[] value, int length)
{
if (m_Index + length > m_Buffer.Length)
{
Flush();
}
Buffer.BlockCopy(value, 0, m_Buffer, m_Index, length);
m_Index += length;
}
public void Write(sbyte value)
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = (byte)value;
}
public void Write(bool value)
{
if (m_Index + 1 > m_Buffer.Length)
{
Flush();
}
m_Buffer[m_Index++] = (byte)(value ? 1 : 0);
}
public void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
public void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
public void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
public void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
public void Write(Map value)
{
if (value != null)
{
Write((byte)value.MapIndex);
}
else
{
Write((byte)0xFF);
}
}
public void Write(Race value)
{
if (value != null)
{
Write((byte)value.RaceIndex);
}
else
{
Write((byte)0xFF);
}
}
public void WriteEntity(IEntity value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(Item value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(Mobile value)
{
if (value?.Deleted != false)
{
Write(Serial.MinusOne);
}
else
{
Write(value.Serial);
}
}
public void Write(BaseGuild value)
{
if (value == null)
{
Write(0);
}
else
{
Write(value.Serial);
}
}
public void WriteItem<T>(T value) where T : Item
{
Write(value);
}
public void WriteMobile<T>(T value) where T : Mobile
{
Write(value);
}
public void WriteGuild<T>(T value) where T : BaseGuild
{
Write(value);
}
public void Write(List<Item> list)
{
WriteItemList(list);
}
public void Write(List<Item> list, bool tidy)
{
WriteItemList(list, tidy);
}
public void WriteItemList<T>(List<T> list) where T : Item
{
WriteItemList(list, false);
}
public void WriteItemList<T>(List<T> list, bool tidy) where T : Item
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i]?.Deleted != false)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<Item> set)
{
Write(set, false);
}
public void Write(HashSet<Item> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(item => item.Deleted);
}
Write(set.Count);
foreach (var item in set)
{
Write(item);
}
}
public void WriteItemSet<T>(HashSet<T> set) where T : Item
{
WriteItemSet(set, false);
}
public void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item
{
if (tidy)
{
set.RemoveWhere(item => item.Deleted);
}
Write(set.Count);
foreach (var item in set)
{
Write(item);
}
}
public void Write(List<Mobile> list)
{
Write(list, false);
}
public void Write(List<Mobile> list, bool tidy)
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Deleted)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void WriteMobileList<T>(List<T> list) where T : Mobile
{
WriteMobileList(list, false);
}
public void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Deleted)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<Mobile> set)
{
Write(set, false);
}
public void Write(HashSet<Mobile> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(mobile => mobile.Deleted);
}
Write(set.Count);
foreach (var mob in set)
{
Write(mob);
}
}
public void WriteMobileSet<T>(HashSet<T> set) where T : Mobile
{
WriteMobileSet(set, false);
}
public void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile
{
if (tidy)
{
set.RemoveWhere(mob => mob.Deleted);
}
Write(set.Count);
foreach (var mob in set)
{
Write(mob);
}
}
public void Write(List<BaseGuild> list)
{
Write(list, false);
}
public void Write(List<BaseGuild> list, bool tidy)
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Disbanded)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void WriteGuildList<T>(List<T> list) where T : BaseGuild
{
WriteGuildList(list, false);
}
public void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild
{
if (tidy)
{
for (var i = 0; i < list.Count;)
{
if (list[i].Disbanded)
{
list.RemoveAt(i);
}
else
{
++i;
}
}
}
Write(list.Count);
for (var i = 0; i < list.Count; ++i)
{
Write(list[i]);
}
}
public void Write(HashSet<BaseGuild> set)
{
Write(set, false);
}
public void Write(HashSet<BaseGuild> set, bool tidy)
{
if (tidy)
{
set.RemoveWhere(guild => guild.Disbanded);
}
Write(set.Count);
foreach (var guild in set)
{
Write(guild);
}
}
public void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild
{
WriteGuildSet(set, false);
}
public void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild
{
if (tidy)
{
set.RemoveWhere(guild => guild.Disbanded);
}
Write(set.Count);
foreach (var guild in set)
{
Write(guild);
}
}
public void Flush()
public override void Flush()
{
if (m_Index > 0)
{
@ -768,52 +40,18 @@ namespace Server
}
}
internal void InternalWriteString(string value)
public override void Close()
{
var length = m_Encoding.GetByteCount(value);
base.Close();
m_File.Close();
}
WriteEncodedInt(length);
public override long Seek(long offset, SeekOrigin origin)
{
m_Position += m_Index;
m_Index = 0;
if (m_CharacterBuffer == null)
{
m_CharacterBuffer = new byte[LargeByteBufferSize];
m_MaxBufferChars = LargeByteBufferSize / m_Encoding.GetMaxByteCount(1);
}
if (length > LargeByteBufferSize)
{
var current = 0;
var charsLeft = value.Length;
while (charsLeft > 0)
{
var charCount = charsLeft > m_MaxBufferChars ? m_MaxBufferChars : charsLeft;
var byteLength = m_Encoding.GetBytes(value, current, charCount, m_CharacterBuffer, 0);
if (m_Index + byteLength > m_Buffer.Length)
{
Flush();
}
Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
m_Index += byteLength;
current += charCount;
charsLeft -= charCount;
}
}
else
{
var byteLength = m_Encoding.GetBytes(value, 0, value.Length, m_CharacterBuffer, 0);
if (m_Index + byteLength > m_Buffer.Length)
{
Flush();
}
Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
m_Index += byteLength;
}
return m_Position = m_File.Seek(offset, origin);
}
}
}

253
Projects/Server/Serialization/BufferedFileWriter.cs → Projects/Server/Serialization/BufferWriter.cs
View file

@ -15,41 +15,79 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Runtime.CompilerServices;
using System.Text;
using Server.Guilds;
namespace Server
{
public class BufferedFileWriter : IGenericWriter
public class BufferWriter : IGenericWriter
{
private const int LargeByteBufferSize = 256;
private readonly Encoding m_Encoding;
private readonly bool m_PrefixStrings;
protected byte[] m_Buffer;
protected int m_Index;
protected long m_Position;
private readonly char[] m_SingleCharBuffer = new char[1];
private byte[] m_CharacterBuffer;
private int m_Index;
private int m_MaxBufferChars;
public BufferedFileWriter(bool prefixStr)
public BufferWriter(bool prefixStr)
{
m_PrefixStrings = prefixStr;
m_Encoding = Utility.UTF8;
Data = new byte[BufferSize];
m_Buffer = new byte[BufferSize];
}
protected virtual int BufferSize => Data?.Length ?? 64;
protected virtual int BufferSize => 256;
public byte[] Data { get; private set; }
public byte[] Data => m_Buffer;
public long Position => m_Index;
public void Close()
public long Position
{
get => m_Position + m_Index;
set => Seek(value, value < 0 ? SeekOrigin.End : SeekOrigin.Begin);
}
public virtual void Close()
{
if (m_Index > 0)
{
Flush();
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public void Resize(int size)
{
Array.Resize(ref m_Buffer, size);
}
public virtual void Flush()
{
Resize(m_Buffer.Length * 2);
}
public virtual long Seek(long offset, SeekOrigin origin)
{
Flush();
return origin switch
{
SeekOrigin.Begin => m_Position = offset,
SeekOrigin.Current => m_Position += offset,
SeekOrigin.End => m_Position = BufferSize - offset,
_ => m_Position
};
}
public void WriteEncodedInt(int value)
@ -58,21 +96,21 @@ namespace Server
while (v >= 0x80)
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = (byte)(v | 0x80);
m_Buffer[m_Index++] = (byte)(v | 0x80);
v >>= 7;
}
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = (byte)v;
m_Buffer[m_Index++] = (byte)v;
}
public void Write(string value)
@ -81,21 +119,21 @@ namespace Server
{
if (value == null)
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = 0;
m_Buffer[m_Index++] = 0;
}
else
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = 1;
m_Buffer[m_Index++] = 1;
InternalWriteString(value);
}
@ -158,100 +196,100 @@ namespace Server
public void Write(long value)
{
if (m_Index + 8 > Data.Length)
if (m_Index + 8 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
Data[m_Index + 2] = (byte)(value >> 16);
Data[m_Index + 3] = (byte)(value >> 24);
Data[m_Index + 4] = (byte)(value >> 32);
Data[m_Index + 5] = (byte)(value >> 40);
Data[m_Index + 6] = (byte)(value >> 48);
Data[m_Index + 7] = (byte)(value >> 56);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index + 4] = (byte)(value >> 32);
m_Buffer[m_Index + 5] = (byte)(value >> 40);
m_Buffer[m_Index + 6] = (byte)(value >> 48);
m_Buffer[m_Index + 7] = (byte)(value >> 56);
m_Index += 8;
}
public void Write(ulong value)
{
if (m_Index + 8 > Data.Length)
if (m_Index + 8 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
Data[m_Index + 2] = (byte)(value >> 16);
Data[m_Index + 3] = (byte)(value >> 24);
Data[m_Index + 4] = (byte)(value >> 32);
Data[m_Index + 5] = (byte)(value >> 40);
Data[m_Index + 6] = (byte)(value >> 48);
Data[m_Index + 7] = (byte)(value >> 56);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index + 4] = (byte)(value >> 32);
m_Buffer[m_Index + 5] = (byte)(value >> 40);
m_Buffer[m_Index + 6] = (byte)(value >> 48);
m_Buffer[m_Index + 7] = (byte)(value >> 56);
m_Index += 8;
}
public void Write(int value)
{
if (m_Index + 4 > Data.Length)
if (m_Index + 4 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
Data[m_Index + 2] = (byte)(value >> 16);
Data[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Index += 4;
}
public void Write(uint value)
{
if (m_Index + 4 > Data.Length)
if (m_Index + 4 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
Data[m_Index + 2] = (byte)(value >> 16);
Data[m_Index + 3] = (byte)(value >> 24);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index + 2] = (byte)(value >> 16);
m_Buffer[m_Index + 3] = (byte)(value >> 24);
m_Index += 4;
}
public void Write(short value)
{
if (m_Index + 2 > Data.Length)
if (m_Index + 2 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Index += 2;
}
public void Write(ushort value)
{
if (m_Index + 2 > Data.Length)
if (m_Index + 2 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index] = (byte)value;
Data[m_Index + 1] = (byte)(value >> 8);
m_Buffer[m_Index] = (byte)value;
m_Buffer[m_Index + 1] = (byte)(value >> 8);
m_Index += 2;
}
public unsafe void Write(double value)
{
if (m_Index + 8 > Data.Length)
if (m_Index + 8 > m_Buffer.Length)
{
Expand();
Flush();
}
fixed (byte* pBuffer = Data)
fixed (byte* pBuffer = m_Buffer)
{
*(double*)(pBuffer + m_Index) = value;
}
@ -261,12 +299,12 @@ namespace Server
public unsafe void Write(float value)
{
if (m_Index + 4 > Data.Length)
if (m_Index + 4 > m_Buffer.Length)
{
Expand();
Flush();
}
fixed (byte* pBuffer = Data)
fixed (byte* pBuffer = m_Buffer)
{
*(float*)(pBuffer + m_Index) = value;
}
@ -276,61 +314,67 @@ namespace Server
public void Write(char value)
{
if (m_Index + 8 > Data.Length)
if (m_Index + 8 > m_Buffer.Length)
{
Expand();
Flush();
}
m_SingleCharBuffer[0] = value;
var byteCount = m_Encoding.GetBytes(m_SingleCharBuffer, 0, 1, Data, m_Index);
var byteCount = m_Encoding.GetBytes(m_SingleCharBuffer, 0, 1, m_Buffer, m_Index);
m_Index += byteCount;
}
public void Write(byte value)
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = value;
}
public void Write(byte[] value)
{
Write(value, value.Length);
m_Buffer[m_Index++] = value;
}
public void Write(byte[] value, int length)
{
while (m_Index + length > Data.Length)
{
Expand();
}
int remaining = length;
int idx = 0;
Buffer.BlockCopy(value, 0, Data, m_Index, length);
m_Index += length;
while (remaining > 0)
{
int size = Math.Min(m_Buffer.Length - m_Index, remaining);
Buffer.BlockCopy(value, idx, m_Buffer, m_Index, size);
// value.Slice(idx).CopyTo(m_Buffer.AsSpan(m_Index, size));
remaining -= size;
m_Index += size;
idx += size;
if (m_Index == m_Buffer.Length)
{
Flush();
}
}
}
public void Write(sbyte value)
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = (byte)value;
m_Buffer[m_Index++] = (byte)value;
}
public void Write(bool value)
{
if (m_Index + 1 > Data.Length)
if (m_Index + 1 > m_Buffer.Length)
{
Expand();
Flush();
}
Data[m_Index++] = (byte)(value ? 1 : 0);
m_Buffer[m_Index++] = (byte)(value ? 1 : 0);
}
public void Write(Point3D value)
@ -704,18 +748,6 @@ namespace Server
}
}
public void Flush()
{
m_Index = 0;
}
private void Expand()
{
var newBuffer = new byte[BufferSize * 2];
Buffer.BlockCopy(Data, 0, newBuffer, 0, Data.Length);
Data = newBuffer;
}
internal void InternalWriteString(string value)
{
var length = m_Encoding.GetByteCount(value);
@ -738,12 +770,12 @@ namespace Server
var charCount = charsLeft > m_MaxBufferChars ? m_MaxBufferChars : charsLeft;
var byteLength = m_Encoding.GetBytes(value, current, charCount, m_CharacterBuffer, 0);
if (m_Index + byteLength > Data.Length)
if (m_Index + byteLength > m_Buffer.Length)
{
Expand();
Flush();
}
Buffer.BlockCopy(m_CharacterBuffer, 0, Data, m_Index, byteLength);
Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
m_Index += byteLength;
current += charCount;
@ -754,19 +786,14 @@ namespace Server
{
var byteLength = m_Encoding.GetBytes(value, 0, value.Length, m_CharacterBuffer, 0);
if (m_Index + byteLength > Data.Length)
if (m_Index + byteLength > m_Buffer.Length)
{
Expand();
Flush();
}
Buffer.BlockCopy(m_CharacterBuffer, 0, Data, m_Index, byteLength);
Buffer.BlockCopy(m_CharacterBuffer, 0, m_Buffer, m_Index, byteLength);
m_Index += byteLength;
}
}
public void WriteTo(IGenericWriter writer)
{
writer.Write(Data, (int)Position);
}
}
}

23
Projects/Server/Serialization/IGenericWriter.cs
View file

@ -15,6 +15,7 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using Server.Guilds;
@ -23,9 +24,7 @@ namespace Server
public interface IGenericWriter
{
long Position { get; }
void Close();
void Write(string value);
void Write(DateTime value);
void Write(DateTimeOffset value);
@ -41,66 +40,50 @@ namespace Server
void Write(float value);
void Write(char value);
void Write(byte value);
void Write(byte[] value);
void Write(byte[] value, int length);
void Write(sbyte value);
void Write(bool value);
void WriteEncodedInt(int value);
void Write(IPAddress value);
void WriteDeltaTime(DateTime value);
void Write(Point3D value);
void Write(Point2D value);
void Write(Rectangle2D value);
void Write(Rectangle3D value);
void Write(Map value);
void WriteEntity(IEntity value);
void Write(Item value);
void Write(Mobile value);
void Write(BaseGuild value);
void WriteItem<T>(T value) where T : Item;
void WriteMobile<T>(T value) where T : Mobile;
void WriteGuild<T>(T value) where T : BaseGuild;
void Write(Race value);
void Write(List<Item> list);
void Write(List<Item> list, bool tidy);
void WriteItemList<T>(List<T> list) where T : Item;
void WriteItemList<T>(List<T> list, bool tidy) where T : Item;
void Write(HashSet<Item> list);
void Write(HashSet<Item> list, bool tidy);
void WriteItemSet<T>(HashSet<T> set) where T : Item;
void WriteItemSet<T>(HashSet<T> set, bool tidy) where T : Item;
void Write(List<Mobile> list);
void Write(List<Mobile> list, bool tidy);
void WriteMobileList<T>(List<T> list) where T : Mobile;
void WriteMobileList<T>(List<T> list, bool tidy) where T : Mobile;
void Write(HashSet<Mobile> list);
void Write(HashSet<Mobile> list, bool tidy);
void WriteMobileSet<T>(HashSet<T> set) where T : Mobile;
void WriteMobileSet<T>(HashSet<T> set, bool tidy) where T : Mobile;
void Write(List<BaseGuild> list);
void Write(List<BaseGuild> list, bool tidy);
void WriteGuildList<T>(List<T> list) where T : BaseGuild;
void WriteGuildList<T>(List<T> list, bool tidy) where T : BaseGuild;
void Write(HashSet<BaseGuild> list);
void Write(HashSet<BaseGuild> list, bool tidy);
void WriteGuildSet<T>(HashSet<T> set) where T : BaseGuild;
void WriteGuildSet<T>(HashSet<T> set, bool tidy) where T : BaseGuild;
long Seek(long offset, SeekOrigin origin);
}
}

8
Projects/Server/Serialization/ISerializable.cs
View file

@ -13,14 +13,18 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
namespace Server
{
public interface ISerializable
{
BufferedFileWriter SaveBuffer { get; }
BufferWriter SaveBuffer { get; set; }
int TypeRef { get; }
Serial Serial { get; }
void Serialize();
void Serialize(DateTime serializeStart);
void Deserialize(IGenericReader reader);
void Serialize(IGenericWriter writer);
void Delete();
}
}