219 lines
8.5 KiB
C#
219 lines
8.5 KiB
C#
using System;
|
|
using System.Globalization;
|
|
|
|
////TODO: goal should be to end up with this being internal
|
|
|
|
////TODO: instead of using string.Intern, put them in a custom table and allow passing them around as indices
|
|
//// (this will probably also be useful for jobs)
|
|
//// when this is implemented, also allow interning directly from Substrings
|
|
|
|
namespace UnityEngine.InputSystem.Utilities
|
|
{
|
|
/// <summary>
|
|
/// Wraps around a string to allow for faster case-insensitive string comparisons while
|
|
/// preserving original casing.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Unlike <c>string</c>, InternedStrings can be compared with a quick <c>Object.ReferenceEquals</c>
|
|
/// comparison and without actually comparing string contents.
|
|
///
|
|
/// Also, unlike <c>string</c>, the representation of an empty and a <c>null</c> string is identical.
|
|
///
|
|
/// Note that all string comparisons using InternedStrings are both case-insensitive and culture-insensitive.
|
|
///
|
|
/// There is a non-zero cost to creating an InternedString. The first time a new unique InternedString
|
|
/// is encountered, there may also be a GC heap allocation.
|
|
/// </remarks>
|
|
public struct InternedString : IEquatable<InternedString>, IComparable<InternedString>
|
|
{
|
|
private readonly string m_StringOriginalCase;
|
|
private readonly string m_StringLowerCase;
|
|
|
|
/// <summary>
|
|
/// Length of the string in characters. Equivalent to <c>string.Length</c>.
|
|
/// </summary>
|
|
/// <value>Length of the string.</value>
|
|
public int length => m_StringLowerCase?.Length ?? 0;
|
|
|
|
/// <summary>
|
|
/// Initialize the InternedString with the given string. Except if the string is <c>null</c>
|
|
/// or empty, this requires an internal lookup (this is the reason the conversion from <c>string</c>
|
|
/// to InternedString is not implicit).
|
|
/// </summary>
|
|
/// <param name="text">A string. Can be null.</param>
|
|
/// <remarks>
|
|
/// The InternedString preserves the original casing. Meaning that <see cref="ToString()"/> will
|
|
/// return the string as it was supplied through <paramref name="text"/>. However, comparison
|
|
/// between two InternedStrings is still always just a reference comparisons regardless of case
|
|
/// and culture.
|
|
///
|
|
/// <example>
|
|
/// <code>
|
|
/// var lowerCase = new InternedString("text");
|
|
/// var upperCase = new InternedString("TEXT");
|
|
///
|
|
/// // This is still just a quick reference comparison:
|
|
/// if (lowerCase == upperCase)
|
|
/// Debug.Log("True");
|
|
///
|
|
/// // But this prints the strings in their original casing.
|
|
/// Debug.Log(lowerCase);
|
|
/// Debug.Log(upperCase);
|
|
/// </code>
|
|
/// </example>
|
|
/// </remarks>
|
|
public InternedString(string text)
|
|
{
|
|
if (string.IsNullOrEmpty(text))
|
|
{
|
|
m_StringOriginalCase = null;
|
|
m_StringLowerCase = null;
|
|
}
|
|
else
|
|
{
|
|
////TODO: I think instead of string.Intern() this should use a custom weak-referenced intern table
|
|
//// (this way we can also avoid the garbage from ToLower())
|
|
m_StringOriginalCase = string.Intern(text);
|
|
m_StringLowerCase = string.Intern(text.ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether the string is empty, i.e. has a <see cref="length"/> of zero. If so, the
|
|
/// InternedString corresponds to <c>default(InternedString)</c>.
|
|
/// </summary>
|
|
/// <returns>True if the string is empty.</returns>
|
|
public bool IsEmpty()
|
|
{
|
|
return m_StringLowerCase == null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a lower-case version of the string.
|
|
/// </summary>
|
|
/// <returns>A lower-case version of the string.</returns>
|
|
/// <remarks>
|
|
/// InternedStrings internally always store a lower-case version which means that this
|
|
/// method does not incur a GC heap allocation cost.
|
|
/// </remarks>
|
|
public string ToLower()
|
|
{
|
|
return m_StringLowerCase;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare the InternedString to given object.
|
|
/// </summary>
|
|
/// <param name="obj">An object. If it is a <c>string</c>, performs a string comparison. If
|
|
/// it is an InternedString, performs an InternedString-comparison. Otherwise returns false.</param>
|
|
/// <returns>True if the InternedString is equal to <paramref name="obj"/>.</returns>
|
|
public override bool Equals(object obj)
|
|
{
|
|
if (obj is InternedString other)
|
|
return Equals(other);
|
|
|
|
if (obj is string str)
|
|
{
|
|
if (m_StringLowerCase == null)
|
|
return string.IsNullOrEmpty(str);
|
|
return string.Equals(m_StringLowerCase, str.ToLower(CultureInfo.InvariantCulture));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compare two InternedStrings for equality. They are equal if, ignoring case and culture,
|
|
/// their text is equal.
|
|
/// </summary>
|
|
/// <param name="other">Another InternedString.</param>
|
|
/// <returns>True if the two InternedStrings are equal.</returns>
|
|
/// <remarks>
|
|
/// This operation is cheap and does not involve an actual string comparison. Instead,
|
|
/// a simple <c>Object.ReferenceEquals</c> comparison is performed.
|
|
/// </remarks>
|
|
public bool Equals(InternedString other)
|
|
{
|
|
return ReferenceEquals(m_StringLowerCase, other.m_StringLowerCase);
|
|
}
|
|
|
|
public int CompareTo(InternedString other)
|
|
{
|
|
return string.Compare(m_StringLowerCase, other.m_StringLowerCase,
|
|
StringComparison.InvariantCultureIgnoreCase);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compute a hash code for the string. Equivalent to <c>string.GetHashCode</c>.
|
|
/// </summary>
|
|
/// <returns>A hash code.</returns>
|
|
public override int GetHashCode()
|
|
{
|
|
if (m_StringLowerCase == null)
|
|
return 0;
|
|
return m_StringLowerCase.GetHashCode();
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return m_StringOriginalCase ?? string.Empty;
|
|
}
|
|
|
|
public static bool operator==(InternedString a, InternedString b)
|
|
{
|
|
return a.Equals(b);
|
|
}
|
|
|
|
public static bool operator!=(InternedString a, InternedString b)
|
|
{
|
|
return !a.Equals(b);
|
|
}
|
|
|
|
public static bool operator==(InternedString a, string b)
|
|
{
|
|
return string.Compare(a.m_StringLowerCase, b.ToLower(CultureInfo.InvariantCulture),
|
|
StringComparison.InvariantCultureIgnoreCase) == 0;
|
|
}
|
|
|
|
public static bool operator!=(InternedString a, string b)
|
|
{
|
|
return string.Compare(a.m_StringLowerCase, b.ToLower(CultureInfo.InvariantCulture),
|
|
StringComparison.InvariantCultureIgnoreCase) != 0;
|
|
}
|
|
|
|
public static bool operator==(string a, InternedString b)
|
|
{
|
|
return string.Compare(a.ToLower(CultureInfo.InvariantCulture), b.m_StringLowerCase,
|
|
StringComparison.InvariantCultureIgnoreCase) == 0;
|
|
}
|
|
|
|
public static bool operator!=(string a, InternedString b)
|
|
{
|
|
return string.Compare(a.ToLower(CultureInfo.InvariantCulture), b.m_StringLowerCase,
|
|
StringComparison.InvariantCultureIgnoreCase) != 0;
|
|
}
|
|
|
|
public static bool operator<(InternedString left, InternedString right)
|
|
{
|
|
return string.Compare(left.m_StringLowerCase, right.m_StringLowerCase,
|
|
StringComparison.InvariantCultureIgnoreCase) < 0;
|
|
}
|
|
|
|
public static bool operator>(InternedString left, InternedString right)
|
|
{
|
|
return string.Compare(left.m_StringLowerCase, right.m_StringLowerCase,
|
|
StringComparison.InvariantCultureIgnoreCase) > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert the given InternedString back to a <c>string</c>. Equivalent to <see cref="ToString()"/>.
|
|
/// </summary>
|
|
/// <param name="str">An InternedString.</param>
|
|
/// <returns>A string.</returns>
|
|
public static implicit operator string(InternedString str)
|
|
{
|
|
return str.ToString();
|
|
}
|
|
}
|
|
}
|