Merge branch 'master' of https://github.com/Regalis11/Barotrauma into develop

Libraries/BarotraumaLibs/BarotraumaCore/Utils/Identifier.cs

@@ -0,0 +1,169 @@
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace Barotrauma
+{
+    // Identifier struct to eliminate case-sensitive comparisons
+    public readonly struct Identifier : IComparable, IEquatable<Identifier>
+    {
+        public readonly static Identifier Empty = default;
+
+        private readonly static int emptyHash = "".GetHashCode(StringComparison.OrdinalIgnoreCase);
+
+        private readonly string? value;
+        private readonly Lazy<int>? hashCode;
+
+        public string Value => value ?? "";
+        public int HashCode => hashCode?.Value ?? emptyHash;
+
+        public Identifier(string? str)
+        {
+            value = str;
+            hashCode = new Lazy<int>(() => (str ?? "").GetHashCode(StringComparison.OrdinalIgnoreCase));
+        }
+
+        public bool IsEmpty => Value.IsNullOrEmpty();
+
+        public Identifier IfEmpty(in Identifier id)
+            => IsEmpty ? id : this;
+
+        public Identifier Replace(in Identifier subStr, in Identifier newStr)
+            => Replace(subStr.Value, newStr.Value);
+        
+        public Identifier Replace(string subStr, string newStr)
+            => Value.Replace(subStr, newStr, StringComparison.OrdinalIgnoreCase).ToIdentifier();
+
+        public Identifier Remove(Identifier subStr)
+            => Remove(subStr.Value);
+
+        public Identifier Remove(string subStr)
+            => Value.Remove(subStr, StringComparison.OrdinalIgnoreCase).ToIdentifier();
+
+        public override bool Equals(object? obj) =>
+            obj switch
+            {
+                Identifier i => this == i,
+                string s => this == s,
+                _ => base.Equals(obj)
+            };
+
+        public bool StartsWith(string str) => Value.StartsWith(str, StringComparison.OrdinalIgnoreCase);
+
+        public bool StartsWith(Identifier id) => StartsWith(id.Value);
+
+        public bool EndsWith(string str) => Value.EndsWith(str, StringComparison.OrdinalIgnoreCase);
+
+        public bool EndsWith(Identifier id) => EndsWith(id.Value);
+
+        public Identifier AppendIfMissing(string suffix)
+            => EndsWith(suffix) ? this : $"{this}{suffix}".ToIdentifier();
+
+        public Identifier RemoveFromEnd(string suffix)
+            => Value.RemoveFromEnd(suffix, StringComparison.OrdinalIgnoreCase).ToIdentifier();
+
+        public bool Contains(string str) => Value.Contains(str, StringComparison.OrdinalIgnoreCase);
+
+        public bool Contains(in Identifier id) => Contains(id.Value);
+
+        public override string ToString() => Value;
+
+        public override int GetHashCode() => HashCode;
+
+        public int CompareTo(object? obj)
+        {
+            return string.Compare(Value, obj?.ToString() ?? "", StringComparison.InvariantCultureIgnoreCase);
+        }
+
+        public bool Equals([AllowNull] Identifier other)
+        {
+            return this == other;
+        }
+
+        private static bool StringEquality(string? a, string? b)
+            => (a.IsNullOrEmpty() && b.IsNullOrEmpty()) || string.Equals(a, b, StringComparison.OrdinalIgnoreCase);
+        
+        public static bool operator ==(in Identifier a, in Identifier b) =>
+            StringEquality(a.Value, b.Value);
+
+        public static bool operator !=(in Identifier a, in Identifier b) =>
+            !(a == b);
+
+        public static bool operator ==(in Identifier identifier, string? str) =>
+            StringEquality(identifier.Value, str);
+
+        public static bool operator !=(in Identifier identifier, string? str) =>
+            !(identifier == str);
+
+        public static bool operator ==(string? str, in Identifier identifier) =>
+            identifier == str;
+
+        public static bool operator !=(string? str, in Identifier identifier) =>
+            !(identifier == str);
+
+        public static bool operator ==(in Identifier? a, in Identifier? b) =>
+            StringEquality(a?.Value, b?.Value);
+
+        public static bool operator !=(in Identifier? a, in Identifier? b) =>
+            !(a == b);
+
+        public static bool operator ==(in Identifier? a, string? b) =>
+            StringEquality(a?.Value, b);
+
+        public static bool operator !=(in Identifier? a, string? b) =>
+            !(a == b);
+
+        public static bool operator ==(string str, in Identifier? identifier) =>
+            identifier == str;
+
+        public static bool operator !=(string str, in Identifier? identifier) =>
+            !(identifier == str);
+
+        public static implicit operator Identifier(string str)
+        {
+            return new Identifier(str);
+        }
+        public int IndexOf(char c) => Value.IndexOf(c);
+
+        public Identifier this[Range range] => Value[range].ToIdentifier();
+        public Char this[int i] => Value[i];
+    }
+
+    public static class IdentifierExtensions
+    {
+        public static IEnumerable<Identifier> ToIdentifiers(this IEnumerable<string> strings)
+        {
+            foreach (string s in strings)
+            {
+                if (string.IsNullOrEmpty(s)) { continue; }
+                yield return new Identifier(s);
+            }
+        }
+
+        public static Identifier[] ToIdentifiers(this string[] strings)
+            => ((IEnumerable<string>)strings).ToIdentifiers().ToArray();
+
+        public static Identifier ToIdentifier(this string? s)
+        {
+            return new Identifier(s);
+        }
+
+        public static Identifier ToIdentifier<T>(this T t) where T: notnull
+        {
+            return t.ToString().ToIdentifier();
+        }
+
+        public static bool Contains(this ISet<Identifier> set, string identifier)
+        {
+            return set.Contains(identifier.ToIdentifier());
+        }
+
+        public static bool ContainsKey<T>(this IReadOnlyDictionary<Identifier, T> dictionary, string key)
+        {
+            return dictionary.ContainsKey(key.ToIdentifier());
+        }
+    }
+}