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

fix: Cleans up core code (#1187)

Browse source 
**Only one functional change**
* Fixes a bug in LogFactory where `Warning` is being logged as `Information`

Non-functional changes:
* Updates/Fixes copyright headers
* Removes namespace scopes for core files.

View with [whitespace off](https://github.com/modernuo/ModernUO/pull/1187/files?w=1).
This commit is contained in:
Kamron Batman 2022-10-10 21:47:08 -07:00 • committed by GitHub
parent 0138d40bda
commit f268d5d4e2
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
262 changed files with 28527 additions and 28646 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
/*************************************************************************
* ModernUO *
* Copyright 2019-2020 - ModernUO Development Team *
* Copyright 2019-2022 - ModernUO Development Team *
* Email: hi@modernuo.com *
* File: IGenericWriter.cs *
* *
@ -18,151 +18,150 @@ using System.IO;
using System.Net;
using Server.Collections;
namespace Server
namespace Server;
public interface IGenericWriter
{
public interface IGenericWriter
long Position { get; }
void Close();
void Write(string value);
void Write(long value);
void Write(ulong value);
void Write(int value);
void Write(uint value);
void Write(short value);
void Write(ushort value);
void Write(double value);
void Write(float value);
void Write(byte value);
void Write(sbyte value);
void Write(bool value);
void Write(Serial serial);
void Write(DateTime value)
{
long Position { get; }
void Close();
void Write(string value);
void Write(long value);
void Write(ulong value);
void Write(int value);
void Write(uint value);
void Write(short value);
void Write(ushort value);
void Write(double value);
void Write(float value);
void Write(byte value);
void Write(sbyte value);
void Write(bool value);
void Write(Serial serial);
void Write(DateTime value)
// If DateTimeKind is Unspecified, we can't assume it needs to be converted.
if (value.Kind == DateTimeKind.Local)
{
// If DateTimeKind is Unspecified, we can't assume it needs to be converted.
if (value.Kind == DateTimeKind.Local)
{
value = value.ToUniversalTime();
}
Write(value.Ticks);
}
void WriteDeltaTime(DateTime value)
{
if (value == DateTime.MinValue)
{
Write(long.MinValue);
return;
}
if (value == DateTime.MaxValue)
{
Write(long.MaxValue);
return;
}
if (value.Kind == DateTimeKind.Local)
{
value = value.ToUniversalTime();
}
// Technically supports negative deltas for times in the past
Write(value.Ticks - DateTime.UtcNow.Ticks);
}
void Write(IPAddress value)
{
Span<byte> stack = stackalloc byte[16];
value.TryWriteBytes(stack, out var bytesWritten);
Write((byte)bytesWritten);
Write(stack[..bytesWritten]);
}
void Write(TimeSpan value)
{
Write(value.Ticks);
value = value.ToUniversalTime();
}
public void Write(decimal value)
{
var bits = decimal.GetBits(value);
for (var i = 0; i < 4; ++i)
{
Write(bits[i]);
}
}
void WriteEncodedInt(int value)
{
var v = (uint)value;
while (v >= 0x80)
{
Write((byte)(v | 0x80));
v >>= 7;
}
Write((byte)v);
}
void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
void Write(Map value) => Write((byte)(value?.MapIndex ?? 0xFF));
void Write(Race value) => Write((byte)(value?.RaceIndex ?? 0xFF));
void Write(ReadOnlySpan<byte> bytes);
unsafe void WriteEnum<T>(T value) where T : unmanaged, Enum
{
switch (sizeof(T))
{
default: throw new ArgumentException($"Argument of type {typeof(T)} is not a normal enum");
case 1:
{
Write(*(byte*)&value);
break;
}
case 2:
{
Write(*(ushort*)&value);
break;
}
case 4:
{
WriteEncodedInt(*(int*)&value);
break;
}
case 8:
{
Write(*(ulong*)&value);
break;
}
}
}
void Write(Guid guid)
{
Span<byte> stack = stackalloc byte[16];
guid.TryWriteBytes(stack);
Write(stack);
}
void Write(BitArray bitArray);
long Seek(long offset, SeekOrigin origin);
Write(value.Ticks);
}
void WriteDeltaTime(DateTime value)
{
if (value == DateTime.MinValue)
{
Write(long.MinValue);
return;
}
if (value == DateTime.MaxValue)
{
Write(long.MaxValue);
return;
}
if (value.Kind == DateTimeKind.Local)
{
value = value.ToUniversalTime();
}
// Technically supports negative deltas for times in the past
Write(value.Ticks - DateTime.UtcNow.Ticks);
}
void Write(IPAddress value)
{
Span<byte> stack = stackalloc byte[16];
value.TryWriteBytes(stack, out var bytesWritten);
Write((byte)bytesWritten);
Write(stack[..bytesWritten]);
}
void Write(TimeSpan value)
{
Write(value.Ticks);
}
public void Write(decimal value)
{
var bits = decimal.GetBits(value);
for (var i = 0; i < 4; ++i)
{
Write(bits[i]);
}
}
void WriteEncodedInt(int value)
{
var v = (uint)value;
while (v >= 0x80)
{
Write((byte)(v | 0x80));
v >>= 7;
}
Write((byte)v);
}
void Write(Point3D value)
{
Write(value.m_X);
Write(value.m_Y);
Write(value.m_Z);
}
void Write(Point2D value)
{
Write(value.m_X);
Write(value.m_Y);
}
void Write(Rectangle2D value)
{
Write(value.Start);
Write(value.End);
}
void Write(Rectangle3D value)
{
Write(value.Start);
Write(value.End);
}
void Write(Map value) => Write((byte)(value?.MapIndex ?? 0xFF));
void Write(Race value) => Write((byte)(value?.RaceIndex ?? 0xFF));
void Write(ReadOnlySpan<byte> bytes);
unsafe void WriteEnum<T>(T value) where T : unmanaged, Enum
{
switch (sizeof(T))
{
default: throw new ArgumentException($"Argument of type {typeof(T)} is not a normal enum");
case 1:
{
Write(*(byte*)&value);
break;
}
case 2:
{
Write(*(ushort*)&value);
break;
}
case 4:
{
WriteEncodedInt(*(int*)&value);
break;
}
case 8:
{
Write(*(ulong*)&value);
break;
}
}
}
void Write(Guid guid)
{
Span<byte> stack = stackalloc byte[16];
guid.TryWriteBytes(stack);
Write(stack);
}
void Write(BitArray bitArray);
long Seek(long offset, SeekOrigin origin);
}