From 72498055357157f3913a380b55f36441b6b4a7bb Mon Sep 17 00:00:00 2001
From: Ned Twigg <ned.twigg@diffplug.com>
Date: Fri, 24 Jan 2025 10:12:05 -0800
Subject: [PATCH 1/4] Strict nullability with `: Any`, and made `RxBoxImp` a
 bit more efficient.

---
 .../com/diffplug/common/rx/ForwardingBox.kt   | 10 ++--
 .../com/diffplug/common/rx/MappedImp.java     | 58 -------------------
 .../java/com/diffplug/common/rx/MappedImp.kt  | 43 ++++++++++++++
 .../diffplug/common/rx/MultiSelectModel.kt    |  8 ++-
 src/main/java/com/diffplug/common/rx/Rx.kt    |  4 +-
 src/main/java/com/diffplug/common/rx/RxBox.kt | 36 +++++-------
 .../java/com/diffplug/common/rx/RxBoxImp.kt   | 18 ++----
 .../java/com/diffplug/common/rx/RxGetter.kt   |  8 +--
 .../java/com/diffplug/common/rx/RxLockBox.kt  | 17 ++----
 .../com/diffplug/common/rx/RxLockBoxImp.kt    | 28 ++++-----
 10 files changed, 96 insertions(+), 134 deletions(-)
 delete mode 100644 src/main/java/com/diffplug/common/rx/MappedImp.java
 create mode 100644 src/main/java/com/diffplug/common/rx/MappedImp.kt

diff --git a/src/main/java/com/diffplug/common/rx/ForwardingBox.kt b/src/main/java/com/diffplug/common/rx/ForwardingBox.kt
index bafedbc..2de5a7b 100644
--- a/src/main/java/com/diffplug/common/rx/ForwardingBox.kt
+++ b/src/main/java/com/diffplug/common/rx/ForwardingBox.kt
@@ -27,7 +27,7 @@ import kotlinx.coroutines.flow.Flow
  *
  * Especially useful for overridding set().
  */
-open class ForwardingBox<T, BoxType : Box<T>>
+open class ForwardingBox<T : Any, BoxType : Box<T>>
 protected constructor(protected val delegate: BoxType) : Box<T> {
 	override fun get(): T {
 		return delegate.get()
@@ -37,7 +37,7 @@ protected constructor(protected val delegate: BoxType) : Box<T> {
 		delegate.set(value)
 	}
 
-	class Cas<T> protected constructor(delegate: CasBox<T>) :
+	class Cas<T : Any> protected constructor(delegate: CasBox<T>) :
 			ForwardingBox<T, CasBox<T>>(delegate), CasBox<T> {
 		override fun compareAndSet(expect: T, update: T): Boolean {
 			return delegate.compareAndSet(expect, update)
@@ -48,21 +48,21 @@ protected constructor(protected val delegate: BoxType) : Box<T> {
 		}
 	}
 
-	class Lock<T> protected constructor(delegate: LockBox<T>) :
+	class Lock<T : Any> protected constructor(delegate: LockBox<T>) :
 			ForwardingBox<T, LockBox<T>>(delegate), LockBox<T> {
 		override fun lock(): Any {
 			return delegate.lock()
 		}
 	}
 
-	open class Rx<T> protected constructor(delegate: RxBox<T>) :
+	open class Rx<T : Any> protected constructor(delegate: RxBox<T>) :
 			ForwardingBox<T, RxBox<T>>(delegate), RxBox<T> {
 		override fun asFlow(): Flow<T> {
 			return delegate.asFlow()
 		}
 	}
 
-	class RxLock<T> protected constructor(delegate: RxLockBox<T>) :
+	class RxLock<T : Any> protected constructor(delegate: RxLockBox<T>) :
 			ForwardingBox<T, RxLockBox<T>>(delegate), RxLockBox<T> {
 		override fun lock(): Any {
 			return delegate.lock()
diff --git a/src/main/java/com/diffplug/common/rx/MappedImp.java b/src/main/java/com/diffplug/common/rx/MappedImp.java
deleted file mode 100644
index 30c8c80..0000000
--- a/src/main/java/com/diffplug/common/rx/MappedImp.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2020 DiffPlug
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.diffplug.common.rx;
-
-
-import com.diffplug.common.base.Box;
-import com.diffplug.common.base.Converter;
-import java.util.function.Function;
-
-class MappedImp<T, R, BoxType extends Box<T>> implements Box<R> {
-	protected final BoxType delegate;
-	protected final Converter<T, R> converter;
-
-	public MappedImp(BoxType delegate, Converter<T, R> converter) {
-		this.delegate = delegate;
-		this.converter = converter;
-	}
-
-	@Override
-	public R get() {
-		return converter.convertNonNull(delegate.get());
-	}
-
-	@Override
-	public void set(R value) {
-		delegate.set(converter.revertNonNull(value));
-	}
-
-	/** Shortcut for doing a set() on the result of a get(). */
-	@Override
-	public R modify(Function<? super R, ? extends R> mutator) {
-		Box.Nullable<R> result = Box.Nullable.ofNull();
-		delegate.modify(input -> {
-			R unmappedResult = mutator.apply(converter.convertNonNull(input));
-			result.set(unmappedResult);
-			return converter.revertNonNull(unmappedResult);
-		});
-		return result.get();
-	}
-
-	@Override
-	public String toString() {
-		return "[" + delegate + " mapped to " + get() + " by " + converter + "]";
-	}
-}
diff --git a/src/main/java/com/diffplug/common/rx/MappedImp.kt b/src/main/java/com/diffplug/common/rx/MappedImp.kt
new file mode 100644
index 0000000..b32cccb
--- /dev/null
+++ b/src/main/java/com/diffplug/common/rx/MappedImp.kt
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.common.rx
+
+import com.diffplug.common.base.Box
+import com.diffplug.common.base.Converter
+import java.util.function.Function
+
+internal open class MappedImp<T : Any, R : Any, BoxType : Box<T>>(
+		@JvmField protected val delegate: BoxType,
+		@JvmField protected val converter: Converter<T, R>
+) : Box<R> {
+	override fun get(): R = converter.convertNonNull(delegate.get())
+
+	override fun set(value: R) = delegate.set(converter.revertNonNull(value))
+
+	/** Shortcut for doing a set() on the result of a get(). */
+	override fun modify(mutator: Function<in R, out R>): R {
+		val result = Box.Nullable.ofNull<R>()
+		delegate.modify { input: T ->
+			val unmappedResult = mutator.apply(converter.convertNonNull(input))
+			result.set(unmappedResult)
+			converter.revertNonNull(unmappedResult)
+		}
+		return result.get()
+	}
+
+	override fun toString(): String =
+			"[" + delegate + " mapped to " + get() + " by " + converter + "]"
+}
diff --git a/src/main/java/com/diffplug/common/rx/MultiSelectModel.kt b/src/main/java/com/diffplug/common/rx/MultiSelectModel.kt
index cc41a73..267d3b8 100644
--- a/src/main/java/com/diffplug/common/rx/MultiSelectModel.kt
+++ b/src/main/java/com/diffplug/common/rx/MultiSelectModel.kt
@@ -171,10 +171,14 @@ class MultiSelectModel<T : Any>(
 
 	companion object {
 		/** Creates an Optional<Either> from an Either<Optional>. </Optional></Either> */
-		fun <T, U> optEitherFrom(either: Either<Optional<T>, Optional<U>>): Optional<Either<T, U>> {
+		fun <T : Any, U : Any> optEitherFrom(
+				either: Either<Optional<T>, Optional<U>>
+		): Optional<Either<T, U>> {
 			return either.fold({ leftOpt: Optional<T> ->
 				leftOpt.map { l: T -> Either.createLeft(l) }
-			}) { rightOpt: Optional<U> -> rightOpt.map { r: U -> Either.createRight(r) } }
+			}) { rightOpt: Optional<U> ->
+				rightOpt.map { r: U -> Either.createRight(r) }
+			}
 		}
 	}
 }
diff --git a/src/main/java/com/diffplug/common/rx/Rx.kt b/src/main/java/com/diffplug/common/rx/Rx.kt
index c6248a3..85406aa 100644
--- a/src/main/java/com/diffplug/common/rx/Rx.kt
+++ b/src/main/java/com/diffplug/common/rx/Rx.kt
@@ -371,7 +371,7 @@ object Rx {
 
 	/** Reliable way to sync two RxBox to each other. */
 	@JvmStatic
-	fun <T> sync(left: RxBox<T>, right: RxBox<T>) {
+	fun <T : Any> sync(left: RxBox<T>, right: RxBox<T>) {
 		sync(sameThreadExecutor(), left, right)
 	}
 
@@ -380,7 +380,7 @@ object Rx {
 	 * changes
 	 */
 	@JvmStatic
-	fun <T> sync(subscriber: RxSubscriber, left: RxBox<T>, right: RxBox<T>) {
+	fun <T : Any> sync(subscriber: RxSubscriber, left: RxBox<T>, right: RxBox<T>) {
 		val firstChange = Box.Nullable.ofNull<Either<T, T>?>()
 		subscriber.subscribe(left) { leftVal: T ->
 			// the left changed before we could acknowledge it
diff --git a/src/main/java/com/diffplug/common/rx/RxBox.kt b/src/main/java/com/diffplug/common/rx/RxBox.kt
index fdd143d..2c6e74a 100644
--- a/src/main/java/com/diffplug/common/rx/RxBox.kt
+++ b/src/main/java/com/diffplug/common/rx/RxBox.kt
@@ -24,14 +24,12 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 /** [RxGetter] and [Box] combined in one: a value you can set, get, and subscribe to. */
-interface RxBox<T> : RxGetter<T>, Box<T> {
+interface RxBox<T : Any> : RxGetter<T>, Box<T> {
 	/** Returns a read-only version of this `RxBox`. */
-	fun readOnly(): RxGetter<T> {
-		return this
-	}
+	fun readOnly(): RxGetter<T> = this
 
 	/** Maps one `RxBox` to another `RxBox`. */
-	override fun <R> map(converter: Converter<T, R>): RxBox<R> {
+	override fun <R : Any> map(converter: Converter<T, R>): RxBox<R> {
 		return RxBoxImp.Mapped(this, converter)
 	}
 
@@ -70,30 +68,26 @@ interface RxBox<T> : RxGetter<T>, Box<T> {
 
 	companion object {
 		/** Creates an `RxBox` with the given initial value. */
-		@JvmStatic
-		fun <T> of(initial: T): RxBox<T> {
-			return RxBoxImp(initial)
-		}
+		@JvmStatic fun <T : Any> of(initial: T): RxBox<T> = RxBoxImp(initial)
 
 		/**
 		 * Creates an `RxBox` which implements the "getter" part with `RxGetter`, and the setter part
 		 * with `Consumer`.
 		 */
 		@JvmStatic
-		fun <T> from(getter: RxGetter<T>, setter: Consumer<T>): RxBox<T> {
-			return object : RxBox<T> {
-				override fun asFlow(): Flow<T> {
-					return getter.asFlow()
-				}
+		fun <T : Any> from(getter: RxGetter<T>, setter: Consumer<T>): RxBox<T> =
+				object : RxBox<T> {
+					override fun asFlow(): Flow<T> {
+						return getter.asFlow()
+					}
 
-				override fun get(): T {
-					return getter.get()
-				}
+					override fun get(): T {
+						return getter.get()
+					}
 
-				override fun set(value: T) {
-					setter.accept(value)
+					override fun set(value: T) {
+						setter.accept(value)
+					}
 				}
-			}
-		}
 	}
 }
diff --git a/src/main/java/com/diffplug/common/rx/RxBoxImp.kt b/src/main/java/com/diffplug/common/rx/RxBoxImp.kt
index a50661d..8ab0aba 100644
--- a/src/main/java/com/diffplug/common/rx/RxBoxImp.kt
+++ b/src/main/java/com/diffplug/common/rx/RxBoxImp.kt
@@ -21,28 +21,22 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 
-internal open class RxBoxImp<T> private constructor(initial: T, subject: MutableStateFlow<T>) :
-		RxBox<T> {
-	private var value: T = initial
-	private val subject: MutableStateFlow<T> = subject
-
-	constructor(initial: T) : this(initial, MutableStateFlow(initial)) {}
+internal open class RxBoxImp<T : Any>(initial: T) : RxBox<T> {
+	private val subject = MutableStateFlow(initial)
 
 	override fun set(newValue: T) {
-		if (newValue != value) {
-			value = newValue
+		if (subject.value != newValue) {
 			subject.value = newValue
 		}
 	}
 
-	override fun get(): T = value
+	override fun get(): T = subject.value
 
 	override fun asFlow(): Flow<T> = subject
 
-	internal class Mapped<T, R>(delegate: RxBox<T>, converter: Converter<T, R>) :
+	internal class Mapped<T : Any, R : Any>(delegate: RxBox<T>, converter: Converter<T, R>) :
 			MappedImp<T, R, RxBox<T>>(delegate, converter), RxBox<R> {
-		val flow: Flow<R> =
-				delegate.asFlow().map { a: T -> converter.convertNonNull(a) }.distinctUntilChanged()
+		val flow: Flow<R> = delegate.asFlow().map(converter::convertNonNull).distinctUntilChanged()
 
 		override fun asFlow(): Flow<R> = flow
 	}
diff --git a/src/main/java/com/diffplug/common/rx/RxGetter.kt b/src/main/java/com/diffplug/common/rx/RxGetter.kt
index aba1c79..961fada 100644
--- a/src/main/java/com/diffplug/common/rx/RxGetter.kt
+++ b/src/main/java/com/diffplug/common/rx/RxGetter.kt
@@ -36,7 +36,7 @@ import kotlinx.coroutines.flow.map
  * not change (e.g. a field is set to its current value, which produces no change) then the
  * `Observable` will not fire.
  */
-interface RxGetter<T> : IFlowable<T>, Supplier<T> {
+interface RxGetter<T : Any> : IFlowable<T>, Supplier<T> {
 	/**
 	 * Maps an `RxGetter` to a new `RxGetter` by applying the `mapper` function to all of its values.
 	 *
@@ -46,7 +46,7 @@ interface RxGetter<T> : IFlowable<T>, Supplier<T> {
 	 * * Incorrect: `("A", "B", "C") -> map(String::length) = (1, 1, 1)`
 	 * * Correct: `("A", "B", "C") -> map(String::length) = (1)`
 	 */
-	fun <R> map(mapper: Function<in T, out R>): RxGetter<R> {
+	fun <R : Any> map(mapper: Function<in T, out R>): RxGetter<R> {
 		val src = this
 		val mapped = src.asFlow().map { t: T -> mapper.apply(t) }
 		val observable = mapped.distinctUntilChanged()
@@ -70,7 +70,7 @@ interface RxGetter<T> : IFlowable<T>, Supplier<T> {
 		 * recorded by a non-volatile field.
 		 */
 		@JvmStatic
-		fun <T> from(observable: Flow<T>, initialValue: T): RxGetter<T> {
+		fun <T : Any> from(observable: Flow<T>, initialValue: T): RxGetter<T> {
 			val box = Box.of(initialValue)
 			subscribe(observable) { value: T -> box.set(value) }
 			return object : RxGetter<T> {
@@ -90,7 +90,7 @@ interface RxGetter<T> : IFlowable<T>, Supplier<T> {
 		 * As with [.map], the observable only emits a new value if its value has changed.
 		 */
 		@JvmStatic
-		fun <T1, T2, R> combineLatest(
+		fun <T1 : Any, T2 : Any, R : Any> combineLatest(
 				t: RxGetter<out T1>,
 				u: RxGetter<out T2>,
 				combine: BiFunction<in T1, in T2, out R>
diff --git a/src/main/java/com/diffplug/common/rx/RxLockBox.kt b/src/main/java/com/diffplug/common/rx/RxLockBox.kt
index 7a67464..453fc3c 100644
--- a/src/main/java/com/diffplug/common/rx/RxLockBox.kt
+++ b/src/main/java/com/diffplug/common/rx/RxLockBox.kt
@@ -22,11 +22,10 @@ import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 
 /** [RxBox] and [LockBox] in one. */
-interface RxLockBox<T> : LockBox<T>, RxBox<T> {
+interface RxLockBox<T : Any> : LockBox<T>, RxBox<T> {
 	/** RxLockBox must map to another kind of LockBox. */
-	override fun <R> map(converter: Converter<T, R>): RxLockBox<R> {
-		return RxLockBoxImp.Mapped(this, converter)
-	}
+	override fun <R : Any> map(converter: Converter<T, R>): RxLockBox<R> =
+			RxLockBoxImp.Mapped(this, converter)
 
 	override fun enforce(enforcer: Function<in T, out T>): RxLockBox<T> {
 		// this must be a plain-old observable, because it needs to fire
@@ -40,15 +39,9 @@ interface RxLockBox<T> : LockBox<T>, RxBox<T> {
 
 	companion object {
 		/** Creates an `RxLockBox` containing the given value, which uses itself as the lock. */
-		@JvmStatic
-		fun <T> of(value: T): RxLockBox<T> {
-			return RxLockBoxImp(value)
-		}
+		@JvmStatic fun <T : Any> of(value: T): RxLockBox<T> = RxLockBoxImp(value)
 
 		/** Creates an `RxLockBox` containing the given value, which uses `lock` as the lock. */
-		@JvmStatic
-		fun <T> of(value: T, lock: Any): RxLockBox<T> {
-			return RxLockBoxImp(value, lock)
-		}
+		@JvmStatic fun <T : Any> of(value: T, lock: Any): RxLockBox<T> = RxLockBoxImp(value, lock)
 	}
 }
diff --git a/src/main/java/com/diffplug/common/rx/RxLockBoxImp.kt b/src/main/java/com/diffplug/common/rx/RxLockBoxImp.kt
index 29aa3d8..8e3f50a 100644
--- a/src/main/java/com/diffplug/common/rx/RxLockBoxImp.kt
+++ b/src/main/java/com/diffplug/common/rx/RxLockBoxImp.kt
@@ -23,35 +23,31 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.map
 
-internal class RxLockBoxImp<T> : LockBoxImp<T>, RxLockBox<T> {
-	val subject: MutableStateFlow<T>
+internal class RxLockBoxImp<T : Any> : LockBoxImp<T>, RxLockBox<T> {
+	val flow: MutableStateFlow<T>
 
 	constructor(value: T) : super(value) {
-		subject = MutableStateFlow(value)
+		flow = MutableStateFlow(value)
 	}
 
 	constructor(value: T, lock: Any) : super(value, lock) {
-		subject = MutableStateFlow(value)
+		flow = MutableStateFlow(value)
 	}
 
 	override fun set(newValue: T) {
 		synchronized(lock()) {
 			if (newValue != value) {
 				value = newValue
-				subject.value = newValue
+				flow.value = newValue
 			}
 		}
 	}
 
-	override fun asFlow(): Flow<T> {
-		return subject
-	}
+	override fun asFlow(): Flow<T> = flow
 
-	override fun toString(): String {
-		return "RxLockBox.of[" + get() + "]"
-	}
+	override fun toString(): String = "RxLockBox.of[" + get() + "]"
 
-	internal class Mapped<T, R>(delegate: RxLockBox<T>, converter: Converter<T, R>) :
+	internal class Mapped<T : Any, R : Any>(delegate: RxLockBox<T>, converter: Converter<T, R>) :
 			MappedImp<T, R, RxLockBox<T>>(delegate, converter), RxLockBox<R> {
 		val flow: Flow<R>
 
@@ -60,13 +56,9 @@ internal class RxLockBoxImp<T> : LockBoxImp<T>, RxLockBox<T> {
 			flow = mapped.distinctUntilChanged()
 		}
 
-		override fun lock(): Any {
-			return delegate.lock()
-		}
+		override fun lock(): Any = delegate.lock()
 
-		override fun asFlow(): Flow<R> {
-			return flow
-		}
+		override fun asFlow(): Flow<R> = flow
 
 		override fun modify(mutator: Function<in R, out R>): R {
 			val result = Box.Nullable.ofNull<R>()

From 4d468deedb0005e9b815394aea7321ee61fac5c0 Mon Sep 17 00:00:00 2001
From: Ned Twigg <ned.twigg@diffplug.com>
Date: Fri, 24 Jan 2025 11:08:19 -0800
Subject: [PATCH 2/4] Use `@JvmStatic` where appropriate.

---
 src/main/java/com/diffplug/common/rx/Rx.kt | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/diffplug/common/rx/Rx.kt b/src/main/java/com/diffplug/common/rx/Rx.kt
index 85406aa..54cc4d5 100644
--- a/src/main/java/com/diffplug/common/rx/Rx.kt
+++ b/src/main/java/com/diffplug/common/rx/Rx.kt
@@ -100,6 +100,7 @@ import kotlinx.coroutines.flow.merge
  *   (https://diffplug.github.io/durian-swt/javadoc/snapshot/com/diffplug/common/swt/SwtExec.html)
  */
 object Rx {
+	@JvmStatic
 	fun <T> createEmitFlow() =
 			MutableSharedFlow<T>(replay = 0, extraBufferCapacity = 1, BufferOverflow.SUSPEND)
 
@@ -132,6 +133,7 @@ object Rx {
 	 * Creates an Rx instance which will call the given consumer whenever the followed stream or
 	 * future completes, whether with an error or not, and the error (if present) will be logged.
 	 */
+	@JvmStatic
 	fun <T> onTerminateLogError(onTerminate: Consumer<Optional<Throwable>>): RxListener<T> {
 		return RxListener(Consumers.doNothing(), DefaultTerminate(onTerminate))
 	}
@@ -449,5 +451,5 @@ object Rx {
 		}
 	}
 
-	val sentinelJob: Job = Job().apply { cancel() }
+	@JvmStatic val sentinelJob: Job = Job().apply { cancel() }
 }

From e0705103f29a769a7ea532bc4c813b67046a9560 Mon Sep 17 00:00:00 2001
From: Ned Twigg <ned.twigg@diffplug.com>
Date: Fri, 24 Jan 2025 11:09:44 -0800
Subject: [PATCH 3/4] Update changelog.

---
 CHANGES.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/CHANGES.md b/CHANGES.md
index af57d2a..79f198b 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,8 +2,9 @@
 
 ## [Unreleased]
 ### Changed
-- Bump required java from 11 to 17. ([#9](https://github.com/diffplug/durian-rx/pull/9))
+- Add strict nullability to RxBox and improve efficiency. ([#12](https://github.com/diffplug/durian-rx/pull/12))
 - Replace `RxJava Disposable` with `Kotlin Job`, and remove `rxjava` completely. ([#10](https://github.com/diffplug/durian-rx/pull/10))
+- Bump required java from 11 to 17. ([#9](https://github.com/diffplug/durian-rx/pull/9))
 
 ## [4.0.1] - 2022-12-20
 ### Fixed

From 96218656cc8a5cf7f8c8ae427902a15bba030f15 Mon Sep 17 00:00:00 2001
From: Ned Twigg <ned.twigg@diffplug.com>
Date: Fri, 24 Jan 2025 11:20:46 -0800
Subject: [PATCH 4/4] Use Kotlin features

---
 CHANGES.md                                              | 2 +-
 src/main/java/com/diffplug/common/rx/GuardedExecutor.kt | 6 ++----
 src/main/java/com/diffplug/common/rx/RxExecutor.kt      | 5 +----
 3 files changed, 4 insertions(+), 9 deletions(-)

diff --git a/CHANGES.md b/CHANGES.md
index 79f198b..8d72196 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -2,8 +2,8 @@
 
 ## [Unreleased]
 ### Changed
+- **BREAKING** Replace `RxJava Disposable` with `Kotlin Job`, and remove `rxjava` completely. ([#10](https://github.com/diffplug/durian-rx/pull/10))
 - Add strict nullability to RxBox and improve efficiency. ([#12](https://github.com/diffplug/durian-rx/pull/12))
-- Replace `RxJava Disposable` with `Kotlin Job`, and remove `rxjava` completely. ([#10](https://github.com/diffplug/durian-rx/pull/10))
 - Bump required java from 11 to 17. ([#9](https://github.com/diffplug/durian-rx/pull/9))
 
 ## [4.0.1] - 2022-12-20
diff --git a/src/main/java/com/diffplug/common/rx/GuardedExecutor.kt b/src/main/java/com/diffplug/common/rx/GuardedExecutor.kt
index 6040d20..d0592b1 100644
--- a/src/main/java/com/diffplug/common/rx/GuardedExecutor.kt
+++ b/src/main/java/com/diffplug/common/rx/GuardedExecutor.kt
@@ -22,7 +22,6 @@ import java.util.concurrent.Executor
 import java.util.function.Supplier
 import kotlinx.coroutines.Deferred
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.Flow
 
 /**
@@ -33,12 +32,11 @@ import kotlinx.coroutines.flow.Flow
  */
 open class GuardedExecutor(val delegate: RxExecutor, val guard: Chit) : Executor, RxSubscriber {
 	override fun execute(command: Runnable) {
-		delegate.executor().execute(guard.guard(command))
+		delegate.executor.execute(guard.guard(command))
 	}
 
 	/** Creates a runnable which runs on this Executor iff the guard widget is not disposed. */
 	fun wrap(delegate: Runnable): Runnable {
-		Objects.requireNonNull(delegate)
 		return Runnable { execute(guard.guard(delegate)) }
 	}
 
@@ -48,7 +46,7 @@ open class GuardedExecutor(val delegate: RxExecutor, val guard: Chit) : Executor
 			guard.runWhenDisposed { job.cancel() }
 			job
 		} else {
-			SupervisorJob().apply { cancel() }
+			Rx.sentinelJob
 		}
 	}
 
diff --git a/src/main/java/com/diffplug/common/rx/RxExecutor.kt b/src/main/java/com/diffplug/common/rx/RxExecutor.kt
index 004951e..e77880a 100644
--- a/src/main/java/com/diffplug/common/rx/RxExecutor.kt
+++ b/src/main/java/com/diffplug/common/rx/RxExecutor.kt
@@ -33,16 +33,13 @@ import kotlinx.coroutines.flow.onCompletion
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
 
-class RxExecutor
-internal constructor(private val executor: Executor, val dispatcher: CoroutineDispatcher) :
+class RxExecutor internal constructor(val executor: Executor, val dispatcher: CoroutineDispatcher) :
 		RxSubscriber {
 
 	interface Has : Executor {
 		val rxExecutor: RxExecutor
 	}
 
-	fun executor() = executor
-
 	override fun <T> subscribe(flow: Flow<T>, listener: RxListener<T>) {
 		subscribeDisposable(flow, listener)
 	}