added CopyTo & TryGetValue for DurableOrderedSet + extra tests for DurableStack

Author: ledjon-behluli

DurableStateMachines.Tests/DurableOrderedSetTests.cs

@@ -14,6 +14,8 @@ public interface IDurableOrderedSetGrain : IGrainWithStringKey
         Task Clear();
         Task<List<string>> GetAll();
         Task<string[]> GetOrderedItemsAsArray();
+        Task<(bool Found, string? ActualValue)> TryGetValue(string value);
+        Task<string[]> CopyToArray(int arraySize, int arrayIndex);
     }
 
     public class DurableOrderedSetGrain([FromKeyedServices("ordered_set")]
@@ -55,6 +57,20 @@ public async Task Clear()
 
         public Task<List<string>> GetAll() => Task.FromResult(state.ToList());
         public Task<string[]> GetOrderedItemsAsArray() => Task.FromResult(state.OrderedItems.ToArray());
+
+        public Task<(bool Found, string? ActualValue)> TryGetValue(string value)
+        {
+            var found = state.TryGetValue(value, out var actualValue);
+            return Task.FromResult((found, actualValue));
+        }
+
+        public Task<string[]> CopyToArray(int arraySize, int arrayIndex)
+        {
+            var array = new string[arraySize];
+            state.CopyTo(array, arrayIndex);
+
+            return Task.FromResult(array);
+        }
     }
 
     private IDurableOrderedSetGrain GetGrain(string key) => fixture.Cluster.Client.GetGrain<IDurableOrderedSetGrain>(key);
@@ -124,6 +140,54 @@ public async Task OrderedItems()
         Assert.Empty(await grain.GetOrderedItemsAsArray());
     }
 
+    [Fact]
+    public async Task TryGetValue()
+    {
+        var grain = GetGrain("try-get-value");
+
+        var (foundEmpty, valueEmpty) = await grain.TryGetValue("anything");
+        Assert.False(foundEmpty);
+        Assert.Null(valueEmpty);
+
+        await grain.Add("one");
+        await grain.Add("two");
+
+        var (foundExisting, valueExisting) = await grain.TryGetValue("one");
+        Assert.True(foundExisting);
+        Assert.Equal("one", valueExisting);
+
+        var (foundMissing, valueMissing) = await grain.TryGetValue("three");
+        Assert.False(foundMissing);
+        Assert.Null(valueMissing);
+    }
+
+    [Fact]
+    public async Task CopyTo()
+    {
+        var grain = GetGrain("copy-to");
+        var items = new[] { "a", "b", "c" };
+        foreach (var item in items)
+        {
+            await grain.Add(item);
+        }
+
+        var destination1 = await grain.CopyToArray(3, 0);
+        Assert.Equal(items, destination1);
+
+        var destination2 = await grain.CopyToArray(5, 0);
+        Assert.Equal(new[] { "a", "b", "c", null, null }, destination2);
+
+        var destination3 = await grain.CopyToArray(5, 2);
+        Assert.Equal(new[] { null, null, "a", "b", "c" }, destination3);
+
+        await Assert.ThrowsAsync<ArgumentException>(() => grain.CopyToArray(2, 0));
+        await Assert.ThrowsAsync<ArgumentException>(() => grain.CopyToArray(4, 2));
+
+        await grain.Clear();
+        var destination4 = await grain.CopyToArray(5, 0);
+        Assert.Equal(new string[5], destination4);
+    }
+
     [Fact]
     public async Task Persistence()
     {

DurableStateMachines.Tests/DurableStackTests.cs

@@ -15,6 +15,8 @@ public interface IDurableStackGrain : IGrainWithStringKey
         Task<int> GetCount();
         Task Clear();
         Task<List<string>> GetAll();
+        Task<bool> Contains(string value);
+        Task<string[]> CopyToArray(int arraySize, int arrayIndex);
     }
 
     public class DurableStackGrain([FromKeyedServices("stack")] 
@@ -61,6 +63,16 @@ public async Task Clear()
         }
 
         public Task<List<string>> GetAll() => Task.FromResult(state.ToList());
+
+        public Task<bool> Contains(string value) => Task.FromResult(state.Contains(value));
+
+        public Task<string[]> CopyToArray(int arraySize, int arrayIndex)
+        {
+            var array = new string[arraySize];
+            state.CopyTo(array, arrayIndex);
+
+            return Task.FromResult(array);
+        }
     }
 
     private IDurableStackGrain GetGrain(string key) => fixture.Cluster.Client.GetGrain<IDurableStackGrain>(key);
@@ -117,6 +129,55 @@ public async Task BasicOperations()
         Assert.Null(emptyTryPop.Item);
     }
 
+    [Fact]
+    public async Task Contains()
+    {
+        var grain = GetGrain("contains");
+
+        Assert.False(await grain.Contains("anything"));
+
+        await grain.Push("one");
+        await grain.Push("two");
+        await grain.Push("three");
+
+        Assert.True(await grain.Contains("one"));
+        Assert.True(await grain.Contains("two"));
+        Assert.True(await grain.Contains("three"));
+        Assert.False(await grain.Contains("four"));
+
+        await grain.Pop();
+        Assert.False(await grain.Contains("three"));
+        Assert.True(await grain.Contains("two"));
+    }
+
+    [Fact]
+    public async Task CopyTo()
+    {
+        var grain = GetGrain("copy-to");
+
+        await grain.Push("c");
+        await grain.Push("b");
+        await grain.Push("a");
+
+        var expectedItems = new[] { "a", "b", "c" };
+
+        var destination1 = await grain.CopyToArray(3, 0);
+        Assert.Equal(expectedItems, destination1);
+
+        var destination2 = await grain.CopyToArray(5, 0);
+        Assert.Equal(new[] { "a", "b", "c", null, null }, destination2);
+
+        var destination3 = await grain.CopyToArray(5, 2);
+        Assert.Equal(new[] { null, null, "a", "b", "c" }, destination3);
+
+        await Assert.ThrowsAsync<ArgumentException>(() => grain.CopyToArray(2, 0));
+        await Assert.ThrowsAsync<ArgumentException>(() => grain.CopyToArray(4, 2));
+
+        await grain.Clear();
+        var destination4 = await grain.CopyToArray(5, 0);
+        Assert.Equal(new string[5], destination4);
+    }
+
     [Fact]
     public async Task Persistence()
     {

DurableStateMachines/DurableOrderedSet.cs

@@ -1,8 +1,8 @@
 using Microsoft.Extensions.DependencyInjection;
-using Newtonsoft.Json.Linq;
 using System.Buffers;
 using System.Collections;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -41,6 +41,28 @@ public interface IDurableOrderedSet<T> : IEnumerable<T>, IReadOnlyCollection<T>
     /// <returns><c>true</c> if the element was successfully found and removed; otherwise, <c>false</c>.</returns>
     bool Remove(T item);
 
+    /// <summary>
+    /// Searches the set for a given value and returns the equal value it finds, if any.
+    /// </summary>
+    /// <param name="equalValue">The value to search for.</param>
+    /// <param name="actualValue">The value from the set that the search found, or the default value of <typeparamref name="T"/> when the search yielded no match.</param>
+    /// <returns>A value indicating whether the search was successful.</returns>
+    /// <remarks>
+    /// This can be useful when you want to reuse a previously stored reference instead of
+    /// a newly constructed one (so that more sharing of references can occur) or to look up
+    /// a value that has more complete data than the value you currently have, although their
+    /// comparer functions indicate they are equal.
+    /// </remarks>
+    bool TryGetValue(T equalValue, [MaybeNullWhen(false)] out T actualValue);
+
+    /// <summary>
+    /// Copies the set to an existing array, starting at the specified array index.
+    /// The elements copied preserve their original insertion order.
+    /// </summary>
+    /// <param name="array">The destination array.</param>
+    /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param>
+    void CopyTo(T[] array, int arrayIndex);
+
     /// <summary>
     /// Removes all elements from the set.
     /// </summary>
@@ -88,6 +110,10 @@ public int Count
     public ReadOnlySpan<T> OrderedItems => CollectionsMarshal.AsSpan(_list);
 
     public bool Contains(T item) => _set.Contains(item);
+    public bool TryGetValue(T equalValue, [MaybeNullWhen(false)] out T actualValue) => _set.TryGetValue(equalValue, out actualValue);
+    
+    // We use the list's CopyTo in order to preserve the order when the elements are copied to the destination array.
+    public void CopyTo(T[] array, int arrayIndex) => _list.CopyTo(array, arrayIndex);
 
     public bool Add(T item)
     {

DurableStateMachines/DurableStack.cs

@@ -26,10 +26,10 @@ public interface IDurableStack<T> : IEnumerable<T>, IReadOnlyCollection<T>
     bool Contains(T item);
 
     /// <summary>
-    /// Copies the stack to an existing one-dimensional array, starting at the specified array index.
+    /// Copies the stack to an existing array, starting at the specified array index.
     /// The elements are copied from top to bottom.
     /// </summary>
-    /// <param name="array">The destination one-dimensional array.</param>
+    /// <param name="array">The destination  array.</param>
     /// <param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param>
     void CopyTo(T[] array, int arrayIndex);