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

fix: Adds ISpanFormattable to Geometry structs (#1231)

Browse source 
* Adds ISpanFormattable to geometry structs and makes ToString() near-zero-allocation.
* Adds IEquatable, and Parsable to Rectangle3D to get it in-line with the other structs.

Closes #1067
This commit is contained in:
Kamron Batman 2022-11-06 17:37:30 -08:00 • committed by GitHub
parent c75bde55da
commit d7d914df6c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
12 changed files with 721 additions and 195 deletions
Download patch file Download diff file Expand all files Collapse all files

3
Projects/Server/Geometry/Point2D.cs
View file

@ -113,7 +113,8 @@ public struct Point2D
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
=> destination.TryWrite(provider, $"({m_X}, {m_Y})", out charsWritten);
public override string ToString() {
public override string ToString()
{
// Maximum number of characters that are needed to represent this:
// 4 characters for (, )
// Up to 11 characters to represent each integer

25
Projects/Server/Geometry/Point3D.cs
View file

@ -21,7 +21,7 @@ namespace Server;
[Parsable]
public struct Point3D
: IPoint3D, IComparable<Point3D>, IComparable<IPoint3D>, IEquatable<object>, IEquatable<Point3D>,
IEquatable<IPoint3D>
IEquatable<IPoint3D>, ISpanFormattable
{
internal int m_X;
internal int m_Y;
@ -70,8 +70,6 @@ public struct Point3D
m_Z = z;
}
public override string ToString() => $"({m_X}, {m_Y}, {m_Z})";
public bool Equals(Point3D other) => m_X == other.m_X && m_Y == other.m_Y && m_Z == other.m_Z;
public bool Equals(IPoint3D other) =>
@ -164,4 +162,25 @@ public struct Point3D
return m_Z.CompareTo(other.Z);
}
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
=> destination.TryWrite(provider, $"({m_X}, {m_Y}, {m_Z})", out charsWritten);
public override string ToString()
{
// Maximum number of characters that are needed to represent this:
// 6 characters for (, , )
// Up to 11 characters to represent each integer
const int maxLength = 6 + 11 * 3;
Span<char> span = stackalloc char[maxLength];
TryFormat(span, out var charsWritten, null, null);
return span[..charsWritten].ToString();
}
public string ToString(string format, IFormatProvider formatProvider)
{
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
}

195
Projects/Server/Geometry/Rectangle2D.cs
View file

@ -20,37 +20,104 @@ namespace Server;
[NoSort]
[Parsable]
[PropertyObject]
public struct Rectangle2D
public struct Rectangle2D : IEquatable<Rectangle2D>, ISpanFormattable
{
public bool Equals(Rectangle2D other) => m_Start == other.m_Start && m_End == other.m_End;
public static bool operator ==(Rectangle2D l, Rectangle2D r) => l.m_Start == r.m_Start && l.m_End == r.m_End;
public static bool operator !=(Rectangle2D l, Rectangle2D r) => l.m_Start != r.m_Start || l.m_End != r.m_End;
public override int GetHashCode() => HashCode.Combine(m_Start, m_End);
private Point2D m_Start;
private Point2D m_End;
private Point2D _start;
private Point2D _end;
public Rectangle2D(Point2D start, Point2D end)
{
m_Start = start;
m_End = end;
_start = start;
_end = end;
}
public Rectangle2D(int x, int y, int width, int height)
{
m_Start = new Point2D(x, y);
m_End = new Point2D(x + width, y + height);
_start = new Point2D(x, y);
_end = new Point2D(x + width, y + height);
}
public void Set(int x, int y, int width, int height)
{
m_Start = new Point2D(x, y);
m_End = new Point2D(x + width, y + height);
_start = new Point2D(x, y);
_end = new Point2D(x + width, y + height);
}
[CommandProperty(AccessLevel.Counselor)]
public Point2D Start
{
get => _start;
set => _start = value;
}
[CommandProperty(AccessLevel.Counselor)]
public Point2D End
{
get => _end;
set => _end = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int X
{
get => _start.m_X;
set => _start.m_X = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Y
{
get => _start.m_Y;
set => _start.m_Y = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Width
{
get => _end.m_X - _start.m_X;
set => _end.m_X = _start.m_X + value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Height
{
get => _end.m_Y - _start.m_Y;
set => _end.m_Y = _start.m_Y + value;
}
public void MakeHold(Rectangle2D r)
{
if (r._start.m_X < _start.m_X)
{
_start.m_X = r._start.m_X;
}
if (r._start.m_Y < _start.m_Y)
{
_start.m_Y = r._start.m_Y;
}
if (r._end.m_X > _end.m_X)
{
_end.m_X = r._end.m_X;
}
if (r._end.m_Y > _end.m_Y)
{
_end.m_Y = r._end.m_Y;
}
}
public bool Equals(Rectangle2D other) => _start == other._start && _end == other._end;
public override bool Equals(object obj) => obj is Rectangle2D other && Equals(other);
public override int GetHashCode() => HashCode.Combine(_start, _end);
public static bool operator ==(Rectangle2D l, Rectangle2D r) => l._start == r._start && l._end == r._end;
public static bool operator !=(Rectangle2D l, Rectangle2D r) => l._start != r._start || l._end != r._end;
public static Rectangle2D Parse(string value)
{
var start = value.IndexOfOrdinal('(');
@ -76,79 +143,33 @@ public struct Rectangle2D
return new Rectangle2D(x, y, w, h);
}
[CommandProperty(AccessLevel.Counselor)]
public Point2D Start
public bool Contains(Point3D p) =>
_start.m_X <= p.m_X && _start.m_Y <= p.m_Y && _end.m_X > p.m_X && _end.m_Y > p.m_Y;
public bool Contains(Point2D p) =>
_start.m_X <= p.m_X && _start.m_Y <= p.m_Y && _end.m_X > p.m_X && _end.m_Y > p.m_Y;
public bool Contains(int x, int y) =>
_start.m_X <= x && _start.m_Y <= y && _end.m_X > x && _end.m_Y > y;
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
=> destination.TryWrite(provider, $"({X}, {Y})+({Width}, {Height})", out charsWritten);
public override string ToString()
{
get => m_Start;
set => m_Start = value;
// Maximum number of characters that are needed to represent this:
// 9 characters for (, )+(, )
// Up to 11 characters to represent each integer
const int maxLength = 9 + 11 * 4;
Span<char> span = stackalloc char[maxLength];
TryFormat(span, out var charsWritten, null, null);
return span[..charsWritten].ToString();
}
[CommandProperty(AccessLevel.Counselor)]
public Point2D End
public string ToString(string format, IFormatProvider formatProvider)
{
get => m_End;
set => m_End = value;
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
[CommandProperty(AccessLevel.Counselor)]
public int X
{
get => m_Start.m_X;
set => m_Start.m_X = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Y
{
get => m_Start.m_Y;
set => m_Start.m_Y = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Width
{
get => m_End.m_X - m_Start.m_X;
set => m_End.m_X = m_Start.m_X + value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Height
{
get => m_End.m_Y - m_Start.m_Y;
set => m_End.m_Y = m_Start.m_Y + value;
}
public void MakeHold(Rectangle2D r)
{
if (r.m_Start.m_X < m_Start.m_X)
{
m_Start.m_X = r.m_Start.m_X;
}
if (r.m_Start.m_Y < m_Start.m_Y)
{
m_Start.m_Y = r.m_Start.m_Y;
}
if (r.m_End.m_X > m_End.m_X)
{
m_End.m_X = r.m_End.m_X;
}
if (r.m_End.m_Y > m_End.m_Y)
{
m_End.m_Y = r.m_End.m_Y;
}
}
public readonly bool Contains(Point3D p) =>
m_Start.m_X <= p.m_X && m_Start.m_Y <= p.m_Y && m_End.m_X > p.m_X && m_End.m_Y > p.m_Y;
public readonly bool Contains(Point2D p) =>
m_Start.m_X <= p.m_X && m_Start.m_Y <= p.m_Y && m_End.m_X > p.m_X && m_End.m_Y > p.m_Y;
public readonly bool Contains(int x, int y) =>
m_Start.m_X <= x && m_Start.m_Y <= y && m_End.m_X > x && m_End.m_Y > y;
public override string ToString() => $"({X}, {Y})+({Width}, {Height})";
}

139
Projects/Server/Geometry/Rectangle3D.cs
View file

@ -13,129 +13,164 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. *
*************************************************************************/
using System;
using System.Buffers;
namespace Server;
[NoSort]
[Parsable]
[PropertyObject]
public struct Rectangle3D
public struct Rectangle3D : IEquatable<Rectangle3D>, ISpanFormattable
{
private Point3D m_Start;
private Point3D m_End;
private Point3D _start;
private Point3D _end;
public Rectangle3D(Point3D start, Point3D end)
{
m_Start = start;
m_End = end;
_start = start;
_end = end;
}
public Rectangle3D(int x, int y, int z, int width, int height, int depth)
{
m_Start = new Point3D(x, y, z);
m_End = new Point3D(x + width, y + height, z + depth);
_start = new Point3D(x, y, z);
_end = new Point3D(x + width, y + height, z + depth);
}
[CommandProperty(AccessLevel.Counselor)]
public Point3D Start
{
get => m_Start;
set => m_Start = value;
get => _start;
set => _start = value;
}
[CommandProperty(AccessLevel.Counselor)]
public Point3D End
{
get => m_End;
set => m_End = value;
get => _end;
set => _end = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int X
{
get => m_Start.m_X;
set => m_Start.m_X = value;
get => _start.m_X;
set => _start.m_X = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Y
{
get => m_Start.m_Y;
set => m_Start.m_Y = value;
get => _start.m_Y;
set => _start.m_Y = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Z
{
get => m_Start.m_Z;
set => m_Start.m_Z = value;
get => _start.m_Z;
set => _start.m_Z = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Width => m_End.X - m_Start.X;
public int Width => _end.X - _start.X;
[CommandProperty(AccessLevel.Counselor)]
public int Height => m_End.Y - m_Start.Y;
public int Height => _end.Y - _start.Y;
[CommandProperty(AccessLevel.Counselor)]
public int Depth => m_End.Z - m_Start.Z;
public int Depth => _end.Z - _start.Z;
public bool Equals(Rectangle3D other) => _start == other._start && _end == other._end;
public override bool Equals(object obj) => obj is Rectangle3D other && Equals(other);
public static bool operator ==(Rectangle3D l, Rectangle3D r) => l._start == r._start && l._end == r._end;
public static bool operator !=(Rectangle3D l, Rectangle3D r) => l._start != r._start || l._end != r._end;
public override int GetHashCode() => HashCode.Combine(_start, _end);
public void MakeHold(Rectangle3D r)
{
if (r.m_Start.m_X < m_Start.m_X)
if (r._start.m_X < _start.m_X)
{
m_Start.m_X = r.m_Start.m_X;
_start.m_X = r._start.m_X;
}
if (r.m_Start.m_Y < m_Start.m_Y)
if (r._start.m_Y < _start.m_Y)
{
m_Start.m_Y = r.m_Start.m_Y;
_start.m_Y = r._start.m_Y;
}
if (r.m_Start.m_Z < m_Start.m_Z)
if (r._start.m_Z < _start.m_Z)
{
m_Start.m_Z = r.m_Start.m_Z;
_start.m_Z = r._start.m_Z;
}
if (r.m_End.m_X > m_End.m_X)
if (r._end.m_X > _end.m_X)
{
m_End.m_X = r.m_End.m_X;
_end.m_X = r._end.m_X;
}
if (r.m_End.m_Y > m_End.m_Y)
if (r._end.m_Y > _end.m_Y)
{
m_End.m_Y = r.m_End.m_Y;
_end.m_Y = r._end.m_Y;
}
if (r.m_End.m_Z < m_End.m_Z)
if (r._end.m_Z < _end.m_Z)
{
m_End.m_Z = r.m_End.m_Z;
_end.m_Z = r._end.m_Z;
}
}
public bool Contains(Point3D p) =>
p.m_X >= m_Start.m_X
&& p.m_X < m_End.m_X
&& p.m_Y >= m_Start.m_Y
&& p.m_Y < m_End.m_Y
&& p.m_Z >= m_Start.m_Z
&& p.m_Z < m_End.m_Z;
p.m_X >= _start.m_X
&& p.m_X < _end.m_X
&& p.m_Y >= _start.m_Y
&& p.m_Y < _end.m_Y
&& p.m_Z >= _start.m_Z
&& p.m_Z < _end.m_Z;
public bool Contains(Point2D p) =>
p.m_X >= m_Start.m_X
&& p.m_X < m_End.m_X
&& p.m_Y >= m_Start.m_Y
&& p.m_Y < m_End.m_Y;
p.m_X >= _start.m_X
&& p.m_X < _end.m_X
&& p.m_Y >= _start.m_Y
&& p.m_Y < _end.m_Y;
public bool Contains(IPoint2D p) =>
p.X >= m_Start.m_X
&& p.X < m_End.m_X
&& p.Y >= m_Start.m_Y
&& p.Y < m_End.m_Y;
p.X >= _start.m_X
&& p.X < _end.m_X
&& p.Y >= _start.m_Y
&& p.Y < _end.m_Y;
public bool Contains(IPoint3D p) =>
p.X >= m_Start.m_X
&& p.X < m_End.m_X
&& p.Y >= m_Start.m_Y
&& p.Y < m_End.m_Y
&& p.Z >= m_Start.m_Z
&& p.Z < m_End.m_Z;
p.X >= _start.m_X
&& p.X < _end.m_X
&& p.Y >= _start.m_Y
&& p.Y < _end.m_Y
&& p.Z >= _start.m_Z
&& p.Z < _end.m_Z;
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
=> destination.TryWrite(provider, $"({X}, {Y}, {Z})+({Width}, {Height}, {Depth})", out charsWritten);
public override string ToString()
{
// Maximum number of characters that are needed to represent this:
// 13 characters for (, , )+(, , )
// Up to 11 characters to represent each integer
const int maxLength = 13 + 11 * 6;
Span<char> span = stackalloc char[maxLength];
TryFormat(span, out var charsWritten, null, null);
return span[..charsWritten].ToString();
}
public string ToString(string format, IFormatProvider formatProvider)
{
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
}

122
Projects/Server/Geometry/WorldLocation.cs
View file

@ -14,52 +14,53 @@
*************************************************************************/
using System;
using System.Buffers;
using System.Collections.Generic;
namespace Server;
[Parsable]
public struct WorldLocation
: IPoint3D, IComparable<WorldLocation>, IEquatable<object>, IEquatable<WorldLocation>, IEquatable<IEntity>
public struct WorldLocation : IPoint3D, IComparable<WorldLocation>, IEquatable<WorldLocation>, IEquatable<IEntity>,
ISpanFormattable
{
internal Point3D m_Loc;
internal Map m_Map;
internal Point3D _loc;
internal Map _map;
public static readonly WorldLocation Zero = new(0, 0, 0, Map.Internal);
[CommandProperty(AccessLevel.Counselor)]
public Point3D Location
{
get => m_Loc;
set => m_Loc = value;
get => _loc;
set => _loc = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int X
{
get => m_Loc.m_X;
set => m_Loc.m_X = value;
get => _loc.m_X;
set => _loc.m_X = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Y
{
get => m_Loc.m_Y;
set => m_Loc.m_Y = value;
get => _loc.m_Y;
set => _loc.m_Y = value;
}
[CommandProperty(AccessLevel.Counselor)]
public int Z
{
get => m_Loc.m_Z;
set => m_Loc.m_Z = value;
get => _loc.m_Z;
set => _loc.m_Z = value;
}
[CommandProperty(AccessLevel.Counselor)]
public Map Map
{
get => m_Map;
set => m_Map = value;
get => _map;
set => _map = value;
}
public WorldLocation(IEntity e) : this(e.Location.X, e.Location.Y, e.Location.Z, e.Map)
@ -80,65 +81,62 @@ public struct WorldLocation
public WorldLocation(int x, int y, int z, Map map)
{
m_Loc.m_X = x;
m_Loc.m_Y = y;
m_Loc.m_Z = z;
m_Map = map;
_loc.m_X = x;
_loc.m_Y = y;
_loc.m_Z = z;
_map = map;
}
public override string ToString() =>
$"({m_Loc.m_X}, {m_Loc.m_Y}, {m_Loc.m_Z}, {m_Map?.ToString() ?? "(-null-)"})";
public bool Equals(WorldLocation other) =>
m_Loc.Equals(other.m_Loc) && m_Map.MapID == other.m_Map.MapID;
_loc.Equals(other._loc) && _map.MapID == other._map.MapID;
public bool Equals(IEntity other) =>
!ReferenceEquals(other, null) && m_Loc == other.Location &&
m_Map.MapID == other.Map.MapID;
!ReferenceEquals(other, null) && _loc == other.Location &&
_map.MapID == other.Map.MapID;
public override bool Equals(object obj) =>
obj is WorldLocation other && Equals(other);
public override int GetHashCode() => HashCode.Combine(m_Loc, m_Map);
public override int GetHashCode() => HashCode.Combine(_loc, _map);
public int CompareTo(WorldLocation other)
{
var locComparison = m_Loc.CompareTo(other.m_Loc);
return locComparison != 0 ? locComparison : Comparer<Map>.Default.Compare(m_Map, other.m_Map);
var locComparison = _loc.CompareTo(other._loc);
return locComparison != 0 ? locComparison : Comparer<Map>.Default.Compare(_map, other._map);
}
public static implicit operator Point3D(WorldLocation worldLocation) => worldLocation.Location;
public static bool operator ==(WorldLocation l, WorldLocation r) =>
l.m_Loc == r.m_Loc && l.m_Map == r.m_Map;
l._loc == r._loc && l._map == r._map;
public static bool operator ==(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc == r.Location && l.m_Map == r.Map;
!ReferenceEquals(r, null) && l._loc == r.Location && l._map == r.Map;
public static bool operator !=(WorldLocation l, WorldLocation r) => l.m_Loc != r.m_Loc && l.m_Map != r.m_Map;
public static bool operator !=(WorldLocation l, WorldLocation r) => l._loc != r._loc && l._map != r._map;
public static bool operator !=(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc != r.Location && l.m_Map != r.Map;
!ReferenceEquals(r, null) && l._loc != r.Location && l._map != r.Map;
public static bool operator >(WorldLocation l, WorldLocation r) => l.m_Loc > r.m_Loc && l.m_Map == r.m_Map;
public static bool operator >(WorldLocation l, WorldLocation r) => l._loc > r._loc && l._map == r._map;
public static bool operator >(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc > r.Location && l.m_Map == r.Map;
!ReferenceEquals(r, null) && l._loc > r.Location && l._map == r.Map;
public static bool operator <(WorldLocation l, WorldLocation r) => l.m_Loc < r.m_Loc && l.m_Map == r.m_Map;
public static bool operator <(WorldLocation l, WorldLocation r) => l._loc < r._loc && l._map == r._map;
public static bool operator <(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc < r.Location && l.m_Map == r.Map;
!ReferenceEquals(r, null) && l._loc < r.Location && l._map == r.Map;
public static bool operator >=(WorldLocation l, WorldLocation r) => l.m_Loc >= r.m_Loc && l.m_Map == r.m_Map;
public static bool operator >=(WorldLocation l, WorldLocation r) => l._loc >= r._loc && l._map == r._map;
public static bool operator >=(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc >= r.Location && l.m_Map == r.Map;
!ReferenceEquals(r, null) && l._loc >= r.Location && l._map == r.Map;
public static bool operator <=(WorldLocation l, WorldLocation r) => l.m_Loc <= r.m_Loc && l.m_Map == r.m_Map;
public static bool operator <=(WorldLocation l, WorldLocation r) => l._loc <= r._loc && l._map == r._map;
public static bool operator <=(WorldLocation l, IEntity r) =>
!ReferenceEquals(r, null) && l.m_Loc <= r.Location && l.m_Map == r.Map;
!ReferenceEquals(r, null) && l._loc <= r.Location && l._map == r.Map;
public static WorldLocation Parse(string value)
{
@ -164,4 +162,50 @@ public struct WorldLocation
return new WorldLocation(x, y, z, map);
}
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
{
if (_map == null)
{
return destination.TryWrite(provider, $"({_loc.m_X}, {_loc.m_Y}, {_loc.m_Z}) [(-null-)]", out charsWritten);
}
return destination.TryWrite(provider, $"({_loc.m_X}, {_loc.m_Y}, {_loc.m_Z}) [{_map}]", out charsWritten);
}
public override string ToString()
{
if (_map == null)
{
// Maximum number of characters that are needed to represent this:
// 9 characters for (, , ) [(-null-)]
const int staticLength = 17;
// Up to 11 characters to represent each integer
const int maxLength = staticLength + 11 * 3;
Span<char> span = stackalloc char[maxLength];
TryFormat(span, out var charsWritten, null, null);
return span[..charsWritten].ToString();
}
else
{
int charsWritten;
char[] array = ArrayPool<char>.Shared.Rent(128);
Span<char> span = array.AsSpan();
while (!TryFormat(span, out charsWritten, null, null))
{
array = ArrayPool<char>.Shared.Rent(array.Length * 2);
span = array.AsSpan();
}
return span[..charsWritten].ToString();
}
}
public string ToString(string format, IFormatProvider formatProvider)
{
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
}

23
Projects/Server/Maps/Map.cs
View file

@ -314,7 +314,7 @@ public static class PooledEnumeration
}
[Parsable]
public sealed class Map : IComparable<Map>
public sealed class Map : IComparable<Map>, ISpanFormattable
{
public const int SectorSize = 16;
public const int SectorShift = 4;
@ -525,8 +525,29 @@ public sealed class Map : IComparable<Map>
return null;
}
public bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider)
{
if (destination.Length >= Name.Length)
{
Name.CopyTo(destination);
charsWritten = Name.Length;
return true;
}
charsWritten = 0;
return false;
}
public override string ToString() => Name;
public string ToString(string format, IFormatProvider formatProvider)
{
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
public int GetAverageZ(int x, int y)
{
GetAverageZ(x, y, out _, out var avg, out _);

17
Projects/Server/Serial.cs
View file

@ -118,9 +118,22 @@ public readonly struct Serial : IComparable<Serial>, IComparable<uint>, IEquatab
public static Serial operator --(Serial l) => (Serial)(l.Value - 1);
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public override string ToString() => $"{this}";
public override string ToString()
{
// Maximum number of characters that are needed to represent this:
// 2 characters for 0x
// Up to 8 characters to represent the value in hex
Span<char> span = stackalloc char[10];
TryFormat(span, out var charsWritten, null, null);
return span[..charsWritten].ToString();
}
public string ToString(string format, IFormatProvider formatProvider) => ToString();
public string ToString(string format, IFormatProvider formatProvider)
{
// format and formatProvider are not doing anything right now, so use the
// default ToString implementation.
return ToString();
}
public bool TryFormat(
Span<char> destination, out int charsWritten, ReadOnlySpan<char> format, IFormatProvider provider