From 320626cf2ab407581a05468ce7ed994e173b392c Mon Sep 17 00:00:00 2001 From: Toastie Date: Sat, 23 Mar 2024 19:18:18 +1300 Subject: [PATCH] Updated Ellie.Common --- src/Ellie.Common/AsyncLazy.cs | 19 +++ .../Collections/ConcurrentHashSet.cs | 88 +++++++++++ .../Collections/IndexedCollection.cs | 148 ++++++++++++++++++ src/Ellie.Common/Ellie.Common.csproj | 15 ++ src/Ellie.Common/EllieRandom.cs | 69 ++++++++ .../Extensions/ArrayExtensions.cs | 51 ++++++ .../Extensions/EnumerableExtensions.cs | 107 +++++++++++++ .../Extensions/HttpClientExtensions.cs | 35 +++++ src/Ellie.Common/Extensions/PipExtensions.cs | 22 +++ src/Ellie.Common/GlobalUsings.cs | 1 + src/Ellie.Common/Helpers/LogSetup.cs | 36 +++++ .../Helpers/StandardConversions.cs | 7 + src/Ellie.Common/Kwum.cs | 100 ++++++++++++ src/Ellie.Common/QueueRunner.cs | 63 ++++++++ src/Ellie.Common/ShmartBankAmount.cs | 19 +++ src/Ellie.Common/ShmartNumber.cs | 38 +++++ 16 files changed, 818 insertions(+) create mode 100644 src/Ellie.Common/AsyncLazy.cs create mode 100644 src/Ellie.Common/Collections/ConcurrentHashSet.cs create mode 100644 src/Ellie.Common/Collections/IndexedCollection.cs create mode 100644 src/Ellie.Common/Ellie.Common.csproj create mode 100644 src/Ellie.Common/EllieRandom.cs create mode 100644 src/Ellie.Common/Extensions/ArrayExtensions.cs create mode 100644 src/Ellie.Common/Extensions/EnumerableExtensions.cs create mode 100644 src/Ellie.Common/Extensions/HttpClientExtensions.cs create mode 100644 src/Ellie.Common/Extensions/PipExtensions.cs create mode 100644 src/Ellie.Common/GlobalUsings.cs create mode 100644 src/Ellie.Common/Helpers/LogSetup.cs create mode 100644 src/Ellie.Common/Helpers/StandardConversions.cs create mode 100644 src/Ellie.Common/Kwum.cs create mode 100644 src/Ellie.Common/QueueRunner.cs create mode 100644 src/Ellie.Common/ShmartBankAmount.cs create mode 100644 src/Ellie.Common/ShmartNumber.cs diff --git a/src/Ellie.Common/AsyncLazy.cs b/src/Ellie.Common/AsyncLazy.cs new file mode 100644 index 0000000..5c69a0d --- /dev/null +++ b/src/Ellie.Common/AsyncLazy.cs @@ -0,0 +1,19 @@ +using System.Runtime.CompilerServices; + +namespace Ellie.Common; + +public class AsyncLazy : Lazy> +{ + public AsyncLazy(Func valueFactory) + : base(() => Task.Run(valueFactory)) + { + } + + public AsyncLazy(Func> taskFactory) + : base(() => Task.Run(taskFactory)) + { + } + + public TaskAwaiter GetAwaiter() + => Value.GetAwaiter(); +} diff --git a/src/Ellie.Common/Collections/ConcurrentHashSet.cs b/src/Ellie.Common/Collections/ConcurrentHashSet.cs new file mode 100644 index 0000000..19986be --- /dev/null +++ b/src/Ellie.Common/Collections/ConcurrentHashSet.cs @@ -0,0 +1,88 @@ +using System.Diagnostics; + +namespace System.Collections.Generic; + +[DebuggerDisplay("{_backingStore.Count}")] +public sealed class ConcurrentHashSet : IReadOnlyCollection, ICollection where T : notnull +{ + private readonly ConcurrentDictionary _backingStore; + + public ConcurrentHashSet() + => _backingStore = new(); + + public ConcurrentHashSet(IEnumerable values, IEqualityComparer? comparer = null) + => _backingStore = new(values.Select(x => new KeyValuePair(x, true)), comparer); + + public IEnumerator GetEnumerator() + => _backingStore.Keys.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() + => GetEnumerator(); + + /// + /// Adds the specified item to the . + /// + /// The item to add. + /// + /// true if the items was added to the + /// successfully; false if it already exists. + /// + /// + /// The + /// contains too many items. + /// + public bool Add(T item) + => _backingStore.TryAdd(item, true); + + void ICollection.Add(T item) + => Add(item); + + public void Clear() + => _backingStore.Clear(); + + public bool Contains(T item) + => _backingStore.ContainsKey(item); + + public void CopyTo(T[] array, int arrayIndex) + { + ArgumentNullException.ThrowIfNull(array); + + if (arrayIndex < 0) + throw new ArgumentOutOfRangeException(nameof(arrayIndex)); + + if (arrayIndex >= array.Length) + throw new ArgumentOutOfRangeException(nameof(arrayIndex)); + + CopyToInternal(array, arrayIndex); + } + + private void CopyToInternal(T[] array, int arrayIndex) + { + var len = array.Length; + foreach (var (k, _) in _backingStore) + { + if (arrayIndex >= len) + throw new IndexOutOfRangeException(nameof(arrayIndex)); + + array[arrayIndex++] = k; + } + } + + bool ICollection.Remove(T item) + => TryRemove(item); + + public bool TryRemove(T item) + => _backingStore.TryRemove(item, out _); + + public void RemoveWhere(Func predicate) + { + foreach (var elem in this.Where(predicate)) + TryRemove(elem); + } + + public int Count + => _backingStore.Count; + + public bool IsReadOnly + => false; +} \ No newline at end of file diff --git a/src/Ellie.Common/Collections/IndexedCollection.cs b/src/Ellie.Common/Collections/IndexedCollection.cs new file mode 100644 index 0000000..15fdc7f --- /dev/null +++ b/src/Ellie.Common/Collections/IndexedCollection.cs @@ -0,0 +1,148 @@ +using System.Collections; + +namespace Ellie.Common; + +public interface IIndexed +{ + int Index { get; set; } +} + +public class IndexedCollection : IList + where T : class, IIndexed +{ + public List Source { get; } + + public int Count + => Source.Count; + + public bool IsReadOnly + => false; + + public virtual T this[int index] + { + get => Source[index]; + set + { + lock (_locker) + { + value.Index = index; + Source[index] = value; + } + } + } + + private readonly object _locker = new(); + + public IndexedCollection() + => Source = new(); + + public IndexedCollection(IEnumerable source) + { + lock (_locker) + { + Source = source.OrderBy(x => x.Index).ToList(); + UpdateIndexes(); + } + } + + public int IndexOf(T item) + => item?.Index ?? -1; + + public IEnumerator GetEnumerator() + => Source.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() + => Source.GetEnumerator(); + + public void Add(T item) + { + ArgumentNullException.ThrowIfNull(item); + + lock (_locker) + { + item.Index = Source.Count; + Source.Add(item); + } + } + + public virtual void Clear() + { + lock (_locker) + { + Source.Clear(); + } + } + + public bool Contains(T item) + { + lock (_locker) + { + return Source.Contains(item); + } + } + + public void CopyTo(T[] array, int arrayIndex) + { + lock (_locker) + { + Source.CopyTo(array, arrayIndex); + } + } + + public virtual bool Remove(T item) + { + lock (_locker) + { + if (Source.Remove(item)) + { + for (var i = 0; i < Source.Count; i++) + { + if (Source[i].Index != i) + Source[i].Index = i; + } + + return true; + } + } + + return false; + } + + public virtual void Insert(int index, T item) + { + lock (_locker) + { + Source.Insert(index, item); + for (var i = index; i < Source.Count; i++) + Source[i].Index = i; + } + } + + public virtual void RemoveAt(int index) + { + lock (_locker) + { + Source.RemoveAt(index); + for (var i = index; i < Source.Count; i++) + Source[i].Index = i; + } + } + + public void UpdateIndexes() + { + lock (_locker) + { + for (var i = 0; i < Source.Count; i++) + { + if (Source[i].Index != i) + Source[i].Index = i; + } + } + } + + public static implicit operator List(IndexedCollection x) + => x.Source; + + public List ToList() + => Source.ToList(); +} diff --git a/src/Ellie.Common/Ellie.Common.csproj b/src/Ellie.Common/Ellie.Common.csproj new file mode 100644 index 0000000..754532f --- /dev/null +++ b/src/Ellie.Common/Ellie.Common.csproj @@ -0,0 +1,15 @@ + + + + net6.0 + enable + enable + + + + + + + + + diff --git a/src/Ellie.Common/EllieRandom.cs b/src/Ellie.Common/EllieRandom.cs new file mode 100644 index 0000000..efb4b8f --- /dev/null +++ b/src/Ellie.Common/EllieRandom.cs @@ -0,0 +1,69 @@ +#nullable disable +using System.Security.Cryptography; + +namespace Ellie.Common; + +public class EllieRandom : Random +{ + private readonly RandomNumberGenerator _rng; + + public EllieRandom() + => _rng = RandomNumberGenerator.Create(); + + public override int Next() + { + var bytes = new byte[sizeof(int)]; + _rng.GetBytes(bytes); + return Math.Abs(BitConverter.ToInt32(bytes, 0)); + } + + public override int Next(int maxValue) + { + if (maxValue <= 0) + throw new ArgumentOutOfRangeException(nameof(maxValue)); + var bytes = new byte[sizeof(int)]; + _rng.GetBytes(bytes); + return Math.Abs(BitConverter.ToInt32(bytes, 0)) % maxValue; + } + + public override int Next(int minValue, int maxValue) + { + if (minValue > maxValue) + throw new ArgumentOutOfRangeException(nameof(maxValue)); + if (minValue == maxValue) + return minValue; + var bytes = new byte[sizeof(int)]; + _rng.GetBytes(bytes); + var sign = Math.Sign(BitConverter.ToInt32(bytes, 0)); + return (sign * BitConverter.ToInt32(bytes, 0) % (maxValue - minValue)) + minValue; + } + + public long NextLong(long minValue, long maxValue) + { + if (minValue > maxValue) + throw new ArgumentOutOfRangeException(nameof(maxValue)); + if (minValue == maxValue) + return minValue; + var bytes = new byte[sizeof(long)]; + _rng.GetBytes(bytes); + var sign = Math.Sign(BitConverter.ToInt64(bytes, 0)); + return (sign * BitConverter.ToInt64(bytes, 0) % (maxValue - minValue)) + minValue; + } + + public override void NextBytes(byte[] buffer) + => _rng.GetBytes(buffer); + + protected override double Sample() + { + var bytes = new byte[sizeof(double)]; + _rng.GetBytes(bytes); + return Math.Abs((BitConverter.ToDouble(bytes, 0) / double.MaxValue) + 1); + } + + public override double NextDouble() + { + var bytes = new byte[sizeof(double)]; + _rng.GetBytes(bytes); + return BitConverter.ToDouble(bytes, 0); + } +} diff --git a/src/Ellie.Common/Extensions/ArrayExtensions.cs b/src/Ellie.Common/Extensions/ArrayExtensions.cs new file mode 100644 index 0000000..a861220 --- /dev/null +++ b/src/Ellie.Common/Extensions/ArrayExtensions.cs @@ -0,0 +1,51 @@ +namespace Ellie.Common; + +// made for expressions because they almost never get added +// and they get looped through constantly +public static class ArrayExtensions +{ + /// + /// Create a new array from the old array + new element at the end + /// + /// Input array + /// Item to add to the end of the output array + /// Type of the array + /// A new array with the new element at the end + public static T[] With(this T[] input, T added) + { + var newExprs = new T[input.Length + 1]; + Array.Copy(input, 0, newExprs, 0, input.Length); + newExprs[input.Length] = added; + return newExprs; + } + + /// + /// Creates a new array by applying the specified function to every element in the input array + /// + /// Array to modify + /// Function to apply + /// Orignal type of the elements in the array + /// Output type of the elements of the array + /// New array with updated elements + public static TOut[] Map(this TIn[] arr, Func f) + => Array.ConvertAll(arr, x => f(x)); + + /// + /// Creates a new array by applying the specified function to every element in the input array + /// + /// Array to modify + /// Function to apply + /// Orignal type of the elements in the array + /// Output type of the elements of the array + /// New array with updated elements + public static TOut[] Map(this IReadOnlyCollection col, Func f) + { + var toReturn = new TOut[col.Count]; + + var i = 0; + foreach (var item in col) + toReturn[i++] = f(item); + + return toReturn; + } +} diff --git a/src/Ellie.Common/Extensions/EnumerableExtensions.cs b/src/Ellie.Common/Extensions/EnumerableExtensions.cs new file mode 100644 index 0000000..1583b9f --- /dev/null +++ b/src/Ellie.Common/Extensions/EnumerableExtensions.cs @@ -0,0 +1,107 @@ +using System.Security.Cryptography; + +namespace Ellie.Common; + +public static class EnumerableExtensions +{ + /// + /// Concatenates the members of a collection, using the specified separator between each member. + /// + /// Collection to join + /// + /// The character to use as a separator. separator is included in the returned string only if + /// values has more than one element. + /// + /// Optional transformation to apply to each element before concatenation. + /// The type of the members of values. + /// + /// A string that consists of the members of values delimited by the separator character. -or- Empty if values has + /// no elements. + /// + public static string Join(this IEnumerable data, char separator, Func? func = null) + => string.Join(separator, data.Select(func ?? (x => x?.ToString() ?? string.Empty))); + + /// + /// Concatenates the members of a collection, using the specified separator between each member. + /// + /// Collection to join + /// + /// The string to use as a separator.separator is included in the returned string only if values + /// has more than one element. + /// + /// Optional transformation to apply to each element before concatenation. + /// The type of the members of values. + /// + /// A string that consists of the members of values delimited by the separator character. -or- Empty if values has + /// no elements. + /// + public static string Join(this IEnumerable data, string separator, Func? func = null) + => string.Join(separator, data.Select(func ?? (x => x?.ToString() ?? string.Empty))); + + /// + /// Randomize element order by performing the Fisher-Yates shuffle + /// + /// Item type + /// Items to shuffle + public static IReadOnlyList Shuffle(this IEnumerable items) + { + using var provider = RandomNumberGenerator.Create(); + var list = items.ToList(); + var n = list.Count; + while (n > 1) + { + var box = new byte[(n / byte.MaxValue) + 1]; + int boxSum; + do + { + provider.GetBytes(box); + boxSum = box.Sum(b => b); + } while (!(boxSum < n * (byte.MaxValue * box.Length / n))); + + var k = boxSum % n; + n--; + (list[k], list[n]) = (list[n], list[k]); + } + + return list; + } + + /// + /// Initializes a new instance of the class + /// that contains elements copied from the specified + /// has the default concurrency level, has the default initial capacity, + /// and uses the default comparer for the key type. + /// + /// + /// The whose elements are copied to the new + /// . + /// + /// A new instance of the class + public static ConcurrentDictionary ToConcurrent( + this IEnumerable> dict) + where TKey : notnull + => new(dict); + + public static IndexedCollection ToIndexed(this IEnumerable enumerable) + where T : class, IIndexed + => new(enumerable); + + /// + /// Creates a task that will complete when all of the objects in an enumerable + /// collection have completed + /// + /// The tasks to wait on for completion. + /// The type of the completed task. + /// A task that represents the completion of all of the supplied tasks. + public static Task WhenAll(this IEnumerable> tasks) + => Task.WhenAll(tasks); + + /// + /// Creates a task that will complete when all of the objects in an enumerable + /// collection have completed + /// + /// The tasks to wait on for completion. + /// A task that represents the completion of all of the supplied tasks. + public static Task WhenAll(this IEnumerable tasks) + => Task.WhenAll(tasks); +} diff --git a/src/Ellie.Common/Extensions/HttpClientExtensions.cs b/src/Ellie.Common/Extensions/HttpClientExtensions.cs new file mode 100644 index 0000000..1b4b492 --- /dev/null +++ b/src/Ellie.Common/Extensions/HttpClientExtensions.cs @@ -0,0 +1,35 @@ +using System.Net.Http.Headers; + +namespace Ellie.Common; + +public static class HttpClientExtensions +{ + public static HttpClient AddFakeHeaders(this HttpClient http) + { + AddFakeHeaders(http.DefaultRequestHeaders); + return http; + } + + public static void AddFakeHeaders(this HttpHeaders dict) + { + dict.Clear(); + dict.Add("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); + dict.Add("User-Agent", + "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/14.0.835.202 Safari/535.1"); + } + + public static bool IsImage(this HttpResponseMessage msg) + => IsImage(msg, out _); + + public static bool IsImage(this HttpResponseMessage msg, out string? mimeType) + { + mimeType = msg.Content.Headers.ContentType?.MediaType; + if (mimeType is "image/png" or "image/jpeg" or "image/gif") + return true; + + return false; + } + + public static long GetContentLength(this HttpResponseMessage msg) + => msg.Content.Headers.ContentLength ?? long.MaxValue; +} diff --git a/src/Ellie.Common/Extensions/PipExtensions.cs b/src/Ellie.Common/Extensions/PipExtensions.cs new file mode 100644 index 0000000..eb2b5a2 --- /dev/null +++ b/src/Ellie.Common/Extensions/PipExtensions.cs @@ -0,0 +1,22 @@ +namespace Ellie.Common; + +public delegate TOut PipeFunc(in TIn a); +public delegate TOut PipeFunc(in TIn1 a, in TIn2 b); + +public static class PipeExtensions +{ + public static TOut Pipe(this TIn a, Func fn) + => fn(a); + + public static TOut Pipe(this TIn a, PipeFunc fn) + => fn(a); + + public static TOut Pipe(this (TIn1, TIn2) a, PipeFunc fn) + => fn(a.Item1, a.Item2); + + public static (TIn, TExtra) With(this TIn a, TExtra b) + => (a, b); + + public static async Task Pipe(this Task a, Func fn) + => fn(await a); +} diff --git a/src/Ellie.Common/GlobalUsings.cs b/src/Ellie.Common/GlobalUsings.cs new file mode 100644 index 0000000..55fdcac --- /dev/null +++ b/src/Ellie.Common/GlobalUsings.cs @@ -0,0 +1 @@ +global using NonBlocking; \ No newline at end of file diff --git a/src/Ellie.Common/Helpers/LogSetup.cs b/src/Ellie.Common/Helpers/LogSetup.cs new file mode 100644 index 0000000..16e1f05 --- /dev/null +++ b/src/Ellie.Common/Helpers/LogSetup.cs @@ -0,0 +1,36 @@ +using Serilog.Events; +using Serilog.Sinks.SystemConsole.Themes; +using System.Text; +using Serilog; + +namespace Ellie.Common; + +public static class LogSetup +{ + public static void SetupLogger(object source) + { + Log.Logger = new LoggerConfiguration().MinimumLevel.Override("Microsoft", LogEventLevel.Information) + .MinimumLevel.Override("System", LogEventLevel.Information) + .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning) + .Enrich.FromLogContext() + .WriteTo.Console(LogEventLevel.Information, + theme: GetTheme(), + outputTemplate: + "[{Timestamp:HH:mm:ss} {Level:u3}] | #{LogSource} | {Message:lj}{NewLine}{Exception}") + .Enrich.WithProperty("LogSource", source) + .CreateLogger(); + + Console.OutputEncoding = Encoding.UTF8; + } + + private static ConsoleTheme GetTheme() + { + if (Environment.OSVersion.Platform == PlatformID.Unix) + return AnsiConsoleTheme.Code; +#if DEBUG + return AnsiConsoleTheme.Code; +#else + return ConsoleTheme.None; +#endif + } +} diff --git a/src/Ellie.Common/Helpers/StandardConversions.cs b/src/Ellie.Common/Helpers/StandardConversions.cs new file mode 100644 index 0000000..6b68353 --- /dev/null +++ b/src/Ellie.Common/Helpers/StandardConversions.cs @@ -0,0 +1,7 @@ +namespace Ellie.Common; + +public static class StandardConversions +{ + public static double CelsiusToFahrenheit(double cel) + => (cel * 1.8f) + 32; +} diff --git a/src/Ellie.Common/Kwum.cs b/src/Ellie.Common/Kwum.cs new file mode 100644 index 0000000..87e081d --- /dev/null +++ b/src/Ellie.Common/Kwum.cs @@ -0,0 +1,100 @@ +using System.Runtime.CompilerServices; + +namespace Ellie.Common; + +// needs proper invalid input check (character array input out of range) +// needs negative number support +// ReSharper disable once InconsistentNaming +#pragma warning disable IDE1006 +public readonly struct kwum : IEquatable +#pragma warning restore IDE1006 +{ + private const string VALID_CHARACTERS = "23456789abcdefghijkmnpqrstuvwxyz"; + private readonly int _value; + + public kwum(int num) + => _value = num; + + public kwum(in char c) + { + if (!IsValidChar(c)) + throw new ArgumentException("Character needs to be a valid kwum character.", nameof(c)); + + _value = InternalCharToValue(c); + } + + public kwum(in ReadOnlySpan input) + { + _value = 0; + for (var index = 0; index < input.Length; index++) + { + var c = input[index]; + if (!IsValidChar(c)) + throw new ArgumentException("All characters need to be a valid kwum characters.", nameof(input)); + + _value += VALID_CHARACTERS.IndexOf(c) * (int)Math.Pow(VALID_CHARACTERS.Length, input.Length - index - 1); + } + } + + [MethodImpl(MethodImplOptions.AggressiveInlining)] + private static int InternalCharToValue(in char c) + => VALID_CHARACTERS.IndexOf(c); + + public static bool TryParse(in ReadOnlySpan input, out kwum value) + { + value = default; + foreach (var c in input) + { + if (!IsValidChar(c)) + return false; + } + + value = new(input); + return true; + } + + public static kwum operator +(kwum left, kwum right) + => new(left._value + right._value); + + public static bool operator ==(kwum left, kwum right) + => left._value == right._value; + + public static bool operator !=(kwum left, kwum right) + => !(left == right); + + public static implicit operator long(kwum kwum) + => kwum._value; + + public static implicit operator int(kwum kwum) + => kwum._value; + + public static implicit operator kwum(int num) + => new(num); + + public static bool IsValidChar(char c) + => VALID_CHARACTERS.Contains(c); + + public override string ToString() + { + var count = VALID_CHARACTERS.Length; + var localValue = _value; + var arrSize = (int)Math.Log(localValue, count) + 1; + Span chars = new char[arrSize]; + while (localValue > 0) + { + localValue = Math.DivRem(localValue, count, out var rem); + chars[--arrSize] = VALID_CHARACTERS[rem]; + } + + return new(chars); + } + + public override bool Equals(object? obj) + => obj is kwum kw && kw == this; + + public bool Equals(kwum other) + => other == this; + + public override int GetHashCode() + => _value.GetHashCode(); +} diff --git a/src/Ellie.Common/QueueRunner.cs b/src/Ellie.Common/QueueRunner.cs new file mode 100644 index 0000000..80fc691 --- /dev/null +++ b/src/Ellie.Common/QueueRunner.cs @@ -0,0 +1,63 @@ +using System.Threading.Channels; +using Serilog; + +namespace Ellie.Common; + +public sealed class QueueRunner +{ + private readonly Channel> _channel; + private readonly int _delayMs; + + public QueueRunner(int delayMs = 0, int maxCapacity = -1) + { + if (delayMs < 0) + throw new ArgumentOutOfRangeException(nameof(delayMs)); + + _delayMs = delayMs; + _channel = maxCapacity switch + { + 0 or < -1 => throw new ArgumentOutOfRangeException(nameof(maxCapacity)), + -1 => Channel.CreateUnbounded>(new UnboundedChannelOptions() + { + SingleReader = true, + SingleWriter = false, + AllowSynchronousContinuations = true, + }), + _ => Channel.CreateBounded>(new BoundedChannelOptions(maxCapacity) + { + Capacity = maxCapacity, + FullMode = BoundedChannelFullMode.DropOldest, + SingleReader = true, + SingleWriter = false, + AllowSynchronousContinuations = true + }) + }; + } + + public async Task RunAsync(CancellationToken cancel = default) + { + while (true) + { + var func = await _channel.Reader.ReadAsync(cancel); + + try + { + await func(); + } + catch (Exception ex) + { + Log.Warning(ex, "Exception executing a staggered func: {ErrorMessage}", ex.Message); + } + finally + { + if (_delayMs != 0) + { + await Task.Delay(_delayMs, cancel); + } + } + } + } + + public ValueTask EnqueueAsync(Func action) + => _channel.Writer.WriteAsync(action); +} diff --git a/src/Ellie.Common/ShmartBankAmount.cs b/src/Ellie.Common/ShmartBankAmount.cs new file mode 100644 index 0000000..0a6a7d9 --- /dev/null +++ b/src/Ellie.Common/ShmartBankAmount.cs @@ -0,0 +1,19 @@ +namespace Ellie.Common; + +public readonly struct ShmartBankAmount +{ + public long Amount { get; } + public ShmartBankAmount(long amount) + { + Amount = amount; + } + + public static implicit operator ShmartBankAmount(long num) + => new(num); + + public static implicit operator long(ShmartBankAmount num) + => num.Amount; + + public static implicit operator ShmartBankAmount(int num) + => new(num); +} diff --git a/src/Ellie.Common/ShmartNumber.cs b/src/Ellie.Common/ShmartNumber.cs new file mode 100644 index 0000000..be722a0 --- /dev/null +++ b/src/Ellie.Common/ShmartNumber.cs @@ -0,0 +1,38 @@ +namespace Ellie.Common; + +public readonly struct ShmartNumber : IEquatable +{ + public long Value { get; } + + public ShmartNumber(long val) + { + Value = val; + } + + public static implicit operator ShmartNumber(long num) + => new(num); + + public static implicit operator long(ShmartNumber num) + => num.Value; + + public static implicit operator ShmartNumber(int num) + => new(num); + + public override string ToString() + => Value.ToString(); + + public override bool Equals(object? obj) + => obj is ShmartNumber sn && Equals(sn); + + public bool Equals(ShmartNumber other) + => other.Value == Value; + + public override int GetHashCode() + => Value.GetHashCode(); + + public static bool operator ==(ShmartNumber left, ShmartNumber right) + => left.Equals(right); + + public static bool operator !=(ShmartNumber left, ShmartNumber right) + => !(left == right); +}