- backport LCS and RedisType.VectorSet changes from v3

Author: mgravell

src/StackExchange.Redis/APITypes/LCSMatchResult.cs

@@ -1,11 +1,14 @@
 using System;
+using System.ComponentModel;
 
+// ReSharper disable once CheckNamespace
 namespace StackExchange.Redis;
 
 /// <summary>
 /// The result of a LongestCommonSubsequence command with IDX feature.
 /// Returns a list of the positions of each sub-match.
 /// </summary>
+// ReSharper disable once InconsistentNaming
 public readonly struct LCSMatchResult
 {
     internal static LCSMatchResult Null { get; } = new LCSMatchResult(Array.Empty<LCSMatch>(), 0);
@@ -36,20 +39,92 @@ internal LCSMatchResult(LCSMatch[] matches, long matchLength)
         LongestMatchLength = matchLength;
     }
 
+    /// <summary>
+    /// Represents a position range in a string.
+    /// </summary>
+    // ReSharper disable once InconsistentNaming
+    public readonly struct LCSPosition : IEquatable<LCSPosition>
+    {
+        /// <summary>
+        /// The start index of the position.
+        /// </summary>
+        public long Start { get; }
+
+        /// <summary>
+        /// The end index of the position.
+        /// </summary>
+        public long End { get; }
+
+        /// <summary>
+        /// Returns a new Position.
+        /// </summary>
+        /// <param name="start">The start index.</param>
+        /// <param name="end">The end index.</param>
+        public LCSPosition(long start, long end)
+        {
+            Start = start;
+            End = end;
+        }
+
+        /// <inheritdoc/>
+        public override string ToString() => $"[{Start}..{End}]";
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return ((int)Start * 31) + (int)End;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj) => obj is LCSPosition other && Equals(in other);
+
+        /// <summary>
+        /// Compares this position to another for equality.
+        /// </summary>
+        [CLSCompliant(false)]
+        public bool Equals(in LCSPosition other) => Start == other.Start && End == other.End;
+
+        /// <summary>
+        /// Compares this position to another for equality.
+        /// </summary>
+        bool IEquatable<LCSPosition>.Equals(LCSPosition other) => Equals(in other);
+    }
+
     /// <summary>
     /// Represents a sub-match of the longest match. i.e first indexes the matched substring in each string.
     /// </summary>
-    public readonly struct LCSMatch
+    // ReSharper disable once InconsistentNaming
+    public readonly struct LCSMatch : IEquatable<LCSMatch>
     {
+        private readonly LCSPosition _first;
+        private readonly LCSPosition _second;
+
+        /// <summary>
+        /// The position of the matched substring in the first string.
+        /// </summary>
+        public LCSPosition First => _first;
+
+        /// <summary>
+        /// The position of the matched substring in the second string.
+        /// </summary>
+        public LCSPosition Second => _second;
+
         /// <summary>
         /// The first index of the matched substring in the first string.
         /// </summary>
-        public long FirstStringIndex { get; }
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Browsable(false)]
+        public long FirstStringIndex => _first.Start;
 
         /// <summary>
         /// The first index of the matched substring in the second string.
         /// </summary>
-        public long SecondStringIndex { get; }
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        [Browsable(false)]
+        public long SecondStringIndex => _second.Start;
 
         /// <summary>
         /// The length of the match.
@@ -59,14 +134,44 @@ public readonly struct LCSMatch
         /// <summary>
         /// Returns a new Match.
         /// </summary>
-        /// <param name="firstStringIndex">The first index of the matched substring in the first string.</param>
-        /// <param name="secondStringIndex">The first index of the matched substring in the second string.</param>
+        /// <param name="first">The position of the matched substring in the first string.</param>
+        /// <param name="second">The position of the matched substring in the second string.</param>
         /// <param name="length">The length of the match.</param>
-        internal LCSMatch(long firstStringIndex, long secondStringIndex, long length)
+        internal LCSMatch(in LCSPosition first, in LCSPosition second, long length)
         {
-            FirstStringIndex = firstStringIndex;
-            SecondStringIndex = secondStringIndex;
+            _first = first;
+            _second = second;
             Length = length;
         }
+
+        /// <inheritdoc/>
+        public override string ToString() => $"First: {_first}, Second: {_second}, Length: {Length}";
+
+        /// <inheritdoc/>
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hash = 17;
+                hash = (hash * 31) + _first.GetHashCode();
+                hash = (hash * 31) + _second.GetHashCode();
+                hash = (hash * 31) + Length.GetHashCode();
+                return hash;
+            }
+        }
+
+        /// <inheritdoc/>
+        public override bool Equals(object? obj) => obj is LCSMatch other && Equals(in other);
+
+        /// <summary>
+        /// Compares this match to another for equality.
+        /// </summary>
+        [CLSCompliant(false)]
+        public bool Equals(in LCSMatch other) => _first.Equals(in other._first) && _second.Equals(in other._second) && Length == other.Length;
+
+        /// <summary>
+        /// Compares this match to another for equality.
+        /// </summary>
+        bool IEquatable<LCSMatch>.Equals(LCSMatch other) => Equals(in other);
     }
 }

src/StackExchange.Redis/Enums/RedisType.cs

@@ -65,5 +65,11 @@ public enum RedisType
         /// The data-type was not recognised by the client library.
         /// </summary>
         Unknown,
+
+        /// <summary>
+        /// Vector sets are a data type similar to sorted sets, but instead of a score,
+        /// vector set elements have a string representation of a vector.
+        /// </summary>
+        VectorSet,
     }
 }

src/StackExchange.Redis/PublicAPI/PublicAPI.Unshipped.txt

@@ -1 +1,17 @@
 #nullable enable
+override StackExchange.Redis.LCSMatchResult.LCSMatch.Equals(object? obj) -> bool
+override StackExchange.Redis.LCSMatchResult.LCSMatch.GetHashCode() -> int
+override StackExchange.Redis.LCSMatchResult.LCSMatch.ToString() -> string!
+override StackExchange.Redis.LCSMatchResult.LCSPosition.Equals(object? obj) -> bool
+override StackExchange.Redis.LCSMatchResult.LCSPosition.GetHashCode() -> int
+override StackExchange.Redis.LCSMatchResult.LCSPosition.ToString() -> string!
+StackExchange.Redis.LCSMatchResult.LCSMatch.Equals(in StackExchange.Redis.LCSMatchResult.LCSMatch other) -> bool
+StackExchange.Redis.LCSMatchResult.LCSMatch.First.get -> StackExchange.Redis.LCSMatchResult.LCSPosition
+StackExchange.Redis.LCSMatchResult.LCSMatch.Second.get -> StackExchange.Redis.LCSMatchResult.LCSPosition
+StackExchange.Redis.LCSMatchResult.LCSPosition
+StackExchange.Redis.LCSMatchResult.LCSPosition.End.get -> long
+StackExchange.Redis.LCSMatchResult.LCSPosition.Equals(in StackExchange.Redis.LCSMatchResult.LCSPosition other) -> bool
+StackExchange.Redis.LCSMatchResult.LCSPosition.LCSPosition() -> void
+StackExchange.Redis.LCSMatchResult.LCSPosition.LCSPosition(long start, long end) -> void
+StackExchange.Redis.LCSMatchResult.LCSPosition.Start.get -> long
+StackExchange.Redis.RedisType.VectorSet = 8 -> StackExchange.Redis.RedisType

src/StackExchange.Redis/ResultProcessor.cs

@@ -1898,14 +1898,14 @@ protected override bool SetResultCore(PhysicalConnection connection, Message mes
             {
                 switch (result.Resp2TypeArray)
                 {
-                    case ResultType.Array:
-                        SetResult(message, Parse(result));
+                    case ResultType.Array when TryParse(result, out var value):
+                        SetResult(message, value);
                         return true;
                 }
                 return false;
             }
 
-            private static LCSMatchResult Parse(in RawResult result)
+            private static bool TryParse(in RawResult result, out LCSMatchResult value)
             {
                 var topItems = result.GetItems();
                 var matches = new LCSMatchResult.LCSMatch[topItems[1].GetItems().Length];
@@ -1915,14 +1915,35 @@ private static LCSMatchResult Parse(in RawResult result)
                 {
                     var matchItems = match.GetItems();
 
-                    matches[i++] = new LCSMatchResult.LCSMatch(
-                        firstStringIndex: (long)matchItems[0].GetItems()[0].AsRedisValue(),
-                        secondStringIndex: (long)matchItems[1].GetItems()[0].AsRedisValue(),
-                        length: (long)matchItems[2].AsRedisValue());
+                    if (TryReadPosition(matchItems[0], out var first)
+                        && TryReadPosition(matchItems[1], out var second)
+                        && matchItems[2].TryGetInt64(out var length))
+                    {
+                        matches[i++] = new LCSMatchResult.LCSMatch(first, second, length);
+                    }
+                    else
+                    {
+                        value = default;
+                        return false;
+                    }
                 }
                 var len = (long)topItems[3].AsRedisValue();
 
-                return new LCSMatchResult(matches, len);
+                value = new LCSMatchResult(matches, len);
+                return true;
+            }
+
+            private static bool TryReadPosition(in RawResult raw, out LCSMatchResult.LCSPosition position)
+            {
+                // Expecting a 2-element array: [start, end]
+                if (raw.Resp2TypeArray is ResultType.Array && raw.ItemsCount >= 2
+                    && raw[0].TryGetInt64(out var start) && raw[1].TryGetInt64(out var end))
+                {
+                    position = new LCSMatchResult.LCSPosition(start, end);
+                    return true;
+                }
+                position = default;
+                return false;
             }
         }
 

tests/StackExchange.Redis.Tests/StringTests.cs

@@ -967,8 +967,8 @@ public async Task LongestCommonSubsequence()
 
         var stringMatchResult = db.StringLongestCommonSubsequenceWithMatches(key1, key2);
         Assert.Equal(2, stringMatchResult.Matches.Length); // "my" and "text" are the two matches of the result
-        Assert.Equivalent(new LCSMatchResult.LCSMatch(4, 5, length: 4), stringMatchResult.Matches[0]); // the string "text" starts at index 4 in the first string and at index 5 in the second string
-        Assert.Equivalent(new LCSMatchResult.LCSMatch(2, 0, length: 2), stringMatchResult.Matches[1]); // the string "my" starts at index 2 in the first string and at index 0 in the second string
+        Assert.Equivalent(new LCSMatchResult.LCSMatch(new(4, 7), new(5, 8), length: 4), stringMatchResult.Matches[0]); // the string "text" starts at index 4 in the first string and at index 5 in the second string
+        Assert.Equivalent(new LCSMatchResult.LCSMatch(new(2, 3), new(0, 1), length: 2), stringMatchResult.Matches[1]); // the string "my" starts at index 2 in the first string and at index 0 in the second string
 
         stringMatchResult = db.StringLongestCommonSubsequenceWithMatches(key1, key2, 5);
         Assert.Empty(stringMatchResult.Matches); // no matches longer than 5 characters
@@ -1007,8 +1007,8 @@ public async Task LongestCommonSubsequenceAsync()
 
         var stringMatchResult = await db.StringLongestCommonSubsequenceWithMatchesAsync(key1, key2);
         Assert.Equal(2, stringMatchResult.Matches.Length); // "my" and "text" are the two matches of the result
-        Assert.Equivalent(new LCSMatchResult.LCSMatch(4, 5, length: 4), stringMatchResult.Matches[0]); // the string "text" starts at index 4 in the first string and at index 5 in the second string
-        Assert.Equivalent(new LCSMatchResult.LCSMatch(2, 0, length: 2), stringMatchResult.Matches[1]); // the string "my" starts at index 2 in the first string and at index 0 in the second string
+        Assert.Equivalent(new LCSMatchResult.LCSMatch(new(4, 7), new(5, 8), length: 4), stringMatchResult.Matches[0]); // the string "text" starts at index 4 in the first string and at index 5 in the second string
+        Assert.Equivalent(new LCSMatchResult.LCSMatch(new(2, 3), new(0, 1), length: 2), stringMatchResult.Matches[1]); // the string "my" starts at index 2 in the first string and at index 0 in the second string
 
         stringMatchResult = await db.StringLongestCommonSubsequenceWithMatchesAsync(key1, key2, 5);
         Assert.Empty(stringMatchResult.Matches); // no matches longer than 5 characters