private static List <T> GetList <T>(PacketReader reader, IPacketConverter converter)
{
var itm = reader.GetList();
var len = itm.Count;
if (len < 1)
{
return(new List <T>());
}
var lst = new List <T>(len);
var gen = converter as IPacketConverter <T>;
try
{
if (gen != null)
{
for (int i = 0; i < len; i++)
{
lst.Add(gen.GetValue(itm[i].element));
}
}
else
{
for (int i = 0; i < len; i++)
{
lst.Add((T)converter.GetValue(itm[i].element));
}
}
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
return(lst);
}
internal static byte[][] GetBytesFromEnumerable <T>(IPacketConverter converter, IEnumerable <T> enumerable)
{
if (enumerable is ICollection <T> col && col.Count > 15)
{
return(GetBytesFromArray(converter, col.ToArray()));
}
var res = new List <byte[]>();
if (converter is IPacketConverter <T> gen)
{
foreach (var i in enumerable)
{
res.Add(gen.GetBytesWrap(i));
}
}
else
{
foreach (var i in enumerable)
{
res.Add(converter.GetBytesWrap(i));
}
}
return(res.ToArray());
}
public PacketParser(ILogger logger)
{
ClassLogger = logger;
SerializerRegister = new SerializationManager();
Converter = new PacketConverter();
}
private static IEnumerator Enumerator(List <PacketReader> list, IPacketConverter converter)
{
for (int idx = 0; idx < list.Count; idx++)
{
yield return(converter.GetValueWrap(list[idx].element));
}
}
public TcpConnection(Socket socket, IPacketConverter packetConverter)
{
Id = Guid.NewGuid().ToString();
_socket = socket;
_packetConverter = packetConverter;
}
private static T[] GetArray <T>(PacketReader reader, IPacketConverter converter)
{
var itm = reader.GetList();
var len = itm.Count;
if (len < 1)
{
return(new T[0]);
}
var arr = new T[len];
var gen = converter as IPacketConverter <T>;
try
{
if (gen != null)
{
for (int i = 0; i < len; i++)
{
arr[i] = gen.GetValue(itm[i].element);
}
}
else
{
for (int i = 0; i < len; i++)
{
arr[i] = (T)converter.GetValue(itm[i].element);
}
}
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
return(arr);
}
internal static List <T> ToList <T>(PacketReader reader, IPacketConverter converter)
{
if (converter.Length < 1)
{
return(GetList <T>(reader, converter));
}
return(reader.element.ToList <T>(converter));
}
internal static T[] ToArray <T>(PacketReader reader, IPacketConverter converter)
{
if (converter.Length < 1)
{
return(GetArray <T>(reader, converter));
}
return(reader.element.ToArray <T>(converter));
}
public void SetUp()
{
request = new SomeRequest();
serverAddress = Mock.Of<IServerAddress>();
packetReceiver = Mock.Of<IPacketReceiver>();
packetConverter = Mock.Of<IPacketConverter>();
responseReceiver = new ResponseReveiver(packetReceiver, packetConverter);
}
public MovePacketSerializer(
IPacketConverter <Guid> guidSerializer,
IPacketConverter <Vector3> vectorSerializer,
IPacketConverter <Quaternion> quaternionSerializer)
{
_guidSerializer = guidSerializer;
_vectorSerializer = vectorSerializer;
_quaternionSerializer = quaternionSerializer;
}
internal T NextAuto <T>(ref int index, IPacketConverter converter)
{
var tmp = index;
MoveNext(converter.Length, ref tmp, out var len);
var res = converter.GetValueWrapAuto <T>(buffer, tmp, len);
index = tmp + len;
return(res);
}
public void Setup()
{
_mockPacket = new MockPacket();
_packetHeader = typeof(MockPacket).AssemblyQualifiedName;
_serializatedMockPacket = "Dummy";
_mockConverter = Substitute.For <IPacketConverter <MockPacket> >();
_mockConverter.Serialize(_mockPacket).Returns(_serializatedMockPacket);
_mockConverter.Deserialize(_serializatedMockPacket).Returns(_mockPacket);
_serializer = new PacketSerializer();
}
internal static byte[][] GetBytesFromEnumerableNonGeneric(IPacketConverter converter, IEnumerable enumerable)
{
var lst = new List <byte[]>();
foreach (var i in enumerable)
{
lst.Add(converter.GetBytesWrap(i));
}
return(lst.ToArray());
}
internal static T GetValueWrap <T>(this IPacketConverter <T> converter, byte[] buffer, int offset, int length)
{
try
{
return(converter.GetValue(buffer, offset, length));
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
}
internal static T GetValueWrap <T>(this IPacketConverter <T> converter, Element element)
{
try
{
return(converter.GetValue(element.buffer, element.offset, element.length));
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
}
public void Setup()
{
_packet = new SpawnPacket(Guid.NewGuid(), new Vector3(), new Quaternion(), "Cat");
_mockGuidSerializer = Substitute.For <IPacketConverter <Guid> >();
_mockVectorSerializer = Substitute.For <IPacketConverter <Vector3> >();
_mockQuaternionSerializer = Substitute.For <IPacketConverter <Quaternion> >();
_serializer = new SpawnPacketSerializer(
_mockGuidSerializer,
_mockVectorSerializer,
_mockQuaternionSerializer);
}
internal static object GetValueWrap(this IPacketConverter converter, byte[] buffer, int offset, int length, bool check = false)
{
try
{
if (check && converter.Length > length)
{
throw PacketException.Overflow();
}
return(converter.GetValue(buffer, offset, length));
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
}
internal List <T> ToList <T>(IPacketConverter converter)
{
if (length < 1)
{
return(new List <T>());
}
if (typeof(T) == typeof(byte))
{
return(new List <T>((T[])GetByteArray()));
}
else if (typeof(T) == typeof(sbyte))
{
return(new List <T>((T[])GetSByteArray()));
}
var def = converter.Length;
var sum = Math.DivRem(length, def, out var rem);
if (rem != 0)
{
throw PacketException.Overflow();
}
var lst = new List <T>(sum);
var gen = converter as IPacketConverter <T>;
try
{
if (gen != null)
{
for (int idx = 0; idx < sum; idx++)
{
lst.Add(gen.GetValue(buffer, offset + idx * def, def));
}
}
else
{
for (int idx = 0; idx < sum; idx++)
{
lst.Add((T)converter.GetValue(buffer, offset + idx * def, def));
}
}
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
return(lst);
}
internal static byte[][] GetBytesFromList <T>(IPacketConverter converter, List <T> list)
{
var res = new byte[list.Count][];
if (converter is IPacketConverter <T> gen)
{
for (int i = 0; i < list.Count; i++)
{
res[i] = gen.GetBytesWrap(list[i]);
}
}
else
{
for (int i = 0; i < list.Count; i++)
{
res[i] = converter.GetBytesWrap(list[i]);
}
}
return(res);
}
internal static byte[][] GetBytesFromArray <T>(IPacketConverter converter, T[] array)
{
var res = new byte[array.Length][];
if (converter is IPacketConverter <T> gen)
{
for (int i = 0; i < array.Length; i++)
{
res[i] = gen.GetBytesWrap(array[i]);
}
}
else
{
for (int i = 0; i < array.Length; i++)
{
res[i] = converter.GetBytesWrap(array[i]);
}
}
return(res);
}
internal static byte[] GetBytesWrap <T>(this IPacketConverter <T> converter, T value)
{
try
{
var buf = converter.GetBytes(value);
if (buf == null)
{
buf = s_empty_bytes;
}
var len = converter.Length;
if (len > 0 && len != buf.Length)
{
throw PacketException.ConvertMismatch(len);
}
return(buf);
}
catch (Exception ex) when(PacketException.WrapFilter(ex))
{
throw PacketException.ConvertError(ex);
}
}
public AbstractTcpServer(IHost host)
{
_host = host;
_serviceProvider = _host.Services;
_tasksCancellationTokenSource = new CancellationTokenSource();
_tasksCancellationToken = _tasksCancellationTokenSource.Token;
_configuration = _serviceProvider.GetRequiredService <IOptions <ServerOptions> >().Value;
_timerService = _serviceProvider.GetRequiredService <TimerService>();
_connectionManager = _serviceProvider.GetRequiredService <ConnectionManager>();
_packetSerializer = _serviceProvider.GetRequiredService <IPacketConverter>();
_logger = _serviceProvider.GetRequiredService <ILogger <AbstractTcpServer> >();
_serverTasks = new ConcurrentBag <Task>();
_packetHandlers = new Dictionary <string, IPacketHandler>();
}
private static IEnumerator Enumerator(byte[] buffer, int offset, int count, int define, IPacketConverter converter)
{
for (int idx = 0; idx < count; idx++)
{
yield return(converter.GetValueWrap(buffer, offset + define * idx, define));
}
}
internal Enumerable(PacketReader reader, IPacketConverter converter)
{
this.reader = reader;
this.converter = converter;
}
internal T NextAuto <T>(IPacketConverter converter) => element.NextAuto <T>(ref index, converter);
internal object Next(IPacketConverter converter) => element.Next(ref index, converter);
internal static object GetValue(this IPacketConverter converter, Element element)
{
return(converter.GetValue(element.buffer, element.offset, element.length));
}
public PingRequestPacketHandler(ILogger <PingRequestPacketHandler> logger, IPacketConverter packetSerializer) : base(packetSerializer)
{
_logger = logger;
}
internal static T GetValue <T>(this IPacketConverter <T> converter, Element element)
{
return(converter.GetValue(element.buffer, element.offset, element.length));
}
internal static T GetValueWrapAuto <T>(this IPacketConverter converter, Element element, bool check = false)
{
return(GetValueWrapAuto <T>(converter, element.buffer, element.offset, element.length, check));
}
public ResponseReveiver(IPacketReceiver packetReceiver, IPacketConverter packetConverter)
{
this.packetReceiver = packetReceiver;
this.packetConverter = packetConverter;
}
public PacketHandler(IPacketConverter packetConverter)
{
_packetConverter = packetConverter;
}
