Killed history

NadekoBot.Core/Common/Kwum.cs

@@ -0,0 +1,98 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace NadekoBot.Core.Common
+{
+    // needs proper invalid input check (character array input out of range)
+    // needs negative number support
+    public readonly struct kwum : IEquatable<kwum>
+    {
+        private readonly int _value;
+        private const string ValidCharacters = "23456789abcdefghijkmnpqrstuvwxyz";
+
+        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);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int InternalCharToValue(in char c) 
+            => ValidCharacters.IndexOf(c);
+
+        public kwum(in ReadOnlySpan<char> 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 += ValidCharacters.IndexOf(c) * (int)Math.Pow(ValidCharacters.Length, input.Length - index - 1);
+            }
+        }
+
+        public static bool TryParse(in ReadOnlySpan<char> input, out kwum value)
+        {
+            value = default;
+            foreach(var c in input)
+                if (!IsValidChar(c))
+                    return false;
+
+            value = new kwum(input);
+            return true;
+        }
+
+        public static kwum operator +(kwum left, kwum right)
+            => new kwum(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 kwum(num);
+
+        public static bool IsValidChar(char c)
+            => ValidCharacters.Contains(c);
+
+        public override string ToString()
+        {
+            var count = ValidCharacters.Length;
+            var localValue = _value;
+            var arrSize = (int)Math.Log(localValue, count) + 1;
+            Span<char> chars = new char[arrSize];
+            while (localValue > 0)
+            {
+                localValue = Math.DivRem(localValue, count, out var rem);
+                chars[--arrSize] = ValidCharacters[(int)rem];
+            }
+
+            return new string(chars);
+        }
+
+        public override bool Equals(object obj)
+            => obj is kwum kw && kw == this;
+
+        public bool Equals(kwum other)
+            => other == this;
+
+        public override int GetHashCode()
+        {
+            return _value.GetHashCode();
+        }
+    }
+}