further improvements - System.Reactive.Extendibility prototyping

Author: Fijo

Assets/Src/Scripts/Data/Linq/DataObservable.cs

@@ -16,7 +16,7 @@ public static IObservable<Unit> AsUnitObservable<T>(this IObservable<T> source)
         }
 
         /// <summary>
-        /// Same as LastOrDefault().AsUnitObservable().
+        /// Like .AsUnitObservable() but only emits once when the source observable was completed and only if it published at least one value before doing so.
         /// </summary>
         public static IObservable<Unit> AsSingleUnitObservable<T>(this IObservable<T> source) {
             if (source == null)

Assets/Src/Scripts/Data/Linq/Observables/AsSingleUnit.cs

@@ -1,5 +1,7 @@
-namespace System.Reactive.Data.Linq.Observables {
-    internal sealed class AsSingleUnit<T> : Producer<Unit, AsSingleUnit<T>._> {
+using System.Reactive.Extendibility.Observables;
+
+namespace System.Reactive.Data.Linq.Observables {
+    internal sealed class AsSingleUnit<T> : ObservableProducer<Unit, AsSingleUnit<T>._> {
         private readonly IObservable<T> _source;
 
         public AsSingleUnit(IObservable<T> source) => _source = source;

Assets/Src/Scripts/Data/Linq/Observables/AsUnit.cs

@@ -1,8 +1,9 @@
 using System;
 using System.Reactive;
+using System.Reactive.Extendibility.Observables;
 
 namespace System.Reactive.Data.Linq.Observables {
-    internal sealed class AsUnit<T> : Producer<Unit, AsUnit<T>._> {
+    internal sealed class AsUnit<T> : ObservableProducer<Unit, AsUnit<T>._> {
         private readonly IObservable<T> _source;
 
         public AsUnit(IObservable<T> source) => _source = source;

Assets/Src/Scripts/Data/Linq/Observables/Pairwise.cs

@@ -1,10 +1,7 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reactive;
+using System.Reactive.Extendibility.Observables;
 
 namespace System.Reactive.Data.Linq.Observables {
-    internal sealed class Pairwise<T> : Producer<Pair<T>, Pairwise<T>._> {
+    internal sealed class Pairwise<T> : ObservableProducer<Pair<T>, Pairwise<T>._> {
         private readonly IObservable<T> _source;
 
         public Pairwise(IObservable<T> source) => _source = source;

Assets/Src/Scripts/Data/System.Reactive.Data.asmdef

@@ -1,7 +1,9 @@
 {
     "name": "System.Reactive.Data",
     "rootNamespace": "",
-    "references": [],
+    "references": [
+        "GUID:1f337dc262e02754a96f0617d03119e8"
+    ],
     "includePlatforms": [],
     "excludePlatforms": [],
     "allowUnsafeCode": false,

Assets/Src/Scripts/Extendibility.meta

@@ -0,0 +1,37 @@
+using System.Reactive.Disposables;
+
+namespace System.Reactive.Extendibility.Disposables {
+    /// <summary>
+    /// Represents a disposable resource that can be checked for disposal status.
+    /// </summary>
+    internal sealed class BooleanDisposable : ICancelable {
+        // Keep internal! This is used as sentinel in other IDisposable implementations to detect disposal and
+        // should never be exposed to user code in order to prevent users from swapping in the sentinel. Have
+        // a look at the code in e.g. SingleAssignmentDisposable for usage patterns.
+        internal static readonly BooleanDisposable True = new BooleanDisposable(true);
+
+        private volatile bool _isDisposed;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BooleanDisposable"/> class.
+        /// </summary>
+        public BooleanDisposable() {
+        }
+
+        private BooleanDisposable(bool isDisposed) {
+            _isDisposed = isDisposed;
+        }
+
+        /// <summary>
+        /// Gets a value that indicates whether the object is disposed.
+        /// </summary>
+        public bool IsDisposed => _isDisposed;
+
+        /// <summary>
+        /// Sets the status to disposed, which can be observer through the <see cref="IsDisposed"/> property.
+        /// </summary>
+        public void Dispose() {
+            _isDisposed = true;
+        }
+    }
+}

Assets/Src/Scripts/Extendibility/Disposables.meta

@@ -0,0 +1,48 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Threading;
+
+namespace System.Reactive.Extendibility.Disposables {
+    internal static partial class Disposable {
+        /// <summary>
+        /// Gets the value stored in <paramref name="fieldRef" /> or a no-op-Disposable if
+        /// <paramref name="fieldRef" /> was already disposed.
+        /// </summary>
+        [return: NotNullIfNotNull("fieldRef")]
+        internal static IDisposable? GetValueOrDefault([NotNullIfNotNull("fieldRef")] /*in*/ ref IDisposable? fieldRef) {
+            var current = Volatile.Read(ref fieldRef);
+
+            return current == BooleanDisposable.True
+                ? System.Reactive.Disposables.Disposable.Empty
+                : current;
+        }
+
+        /// <summary>
+        /// Tries to assign <paramref name="value" /> to <paramref name="fieldRef" />.
+        /// </summary>
+        /// <returns>A <see cref="TrySetSingleResult"/> value indicating the outcome of the operation.</returns>
+        internal static TrySetSingleResult TrySetSingle([NotNullIfNotNull("value")] ref IDisposable? fieldRef, IDisposable? value) {
+            var old = Interlocked.CompareExchange(ref fieldRef, value, null);
+            if (old == null) {
+                return TrySetSingleResult.Success;
+            }
+
+            if (old != BooleanDisposable.True) {
+                return TrySetSingleResult.AlreadyAssigned;
+            }
+
+            value?.Dispose();
+            return TrySetSingleResult.Disposed;
+        }
+
+        /// <summary>
+        /// Disposes <paramref name="fieldRef" />. 
+        /// </summary>
+        internal static void Dispose([NotNullIfNotNull("fieldRef")] ref IDisposable? fieldRef) {
+            var old = Interlocked.Exchange(ref fieldRef, BooleanDisposable.True);
+
+            if (old != BooleanDisposable.True) {
+                old?.Dispose();
+            }
+        }
+    }
+}