Merge pull request #17 from yahoo/sal/0_11_2

slevin · web-flow · commit e7bbf589ecf7 · 2024-12-13T11:34:36.000-08:00
Don't use forced unwrapping
diff --git a/behavior-graph/build.gradle b/behavior-graph/build.gradle
@@ -42,7 +42,7 @@ import com.vanniktech.maven.publish.SonatypeHost
 mavenPublishing {
     configure(new KotlinJvm(new JavadocJar.Dokka("dokkaHtml"), true))
     publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL)
-    coordinates("com.yahoo.behaviorgraph", "bgjvm", "0.11.1")
+    coordinates("com.yahoo.behaviorgraph", "bgjvm", "0.11.2")
     pom {
         name = 'Behavior Graph'
         description = 'Behavior Graph lets you build your programs out of small, easily understood pieces in a way that lets the computer do more of the work for you.'
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/BehaviorBuilder.kt b/behavior-graph/src/main/kotlin/behaviorgraph/BehaviorBuilder.kt
@@ -163,13 +163,13 @@ class BehaviorBuilder<T: Any>(
             val demands: MutableList<Demandable> = mutableListOf()
             dynamicDemandSwitches?.let { demands.addAll(it) }
             if (dynamicDemandRelinkingOrder == RelinkingOrder.RelinkingOrderPrior) {
-                supplies = listOf(dynamicDemandResource!!)
+                dynamicDemandResource?.let { supplies = listOf(it) }
             } else {
-                demands.add(dynamicDemandResource!!)
+                dynamicDemandResource?.let { demands.add(it) }
             }
             Behavior(extent, demands, supplies) {
                 val mutableListOfDemands = mutableListOf<Demandable?>()
-                dynamicDemandLinks!!.invoke(it, mutableListOfDemands)
+                dynamicDemandLinks?.invoke(it, mutableListOfDemands)
                 mainBehavior.setDynamicDemands(mutableListOfDemands)
             }
         }
@@ -179,13 +179,13 @@ class BehaviorBuilder<T: Any>(
             val demands: MutableList<Demandable> = mutableListOf()
             dynamicSupplySwitches?.let { demands.addAll(it) }
             if (dynamicSupplyRelinkingOrder == RelinkingOrder.RelinkingOrderPrior) {
-                supplies = listOf(dynamicSupplyResource!!)
+                dynamicSupplyResource?.let { supplies = listOf(dynamicSupplyResource) }
             } else {
-                demands.add(dynamicSupplyResource!!)
+                dynamicSupplyResource?.let { demands.add(dynamicSupplyResource) }
             }
             Behavior(extent, demands, supplies) {
                 val mutableListOfSupplies = mutableListOf<Resource?>()
-                dynamicSupplyLinks!!.invoke(it, mutableListOfSupplies)
+                dynamicSupplyLinks?.invoke(it, mutableListOfSupplies)
                 mainBehavior.setDynamicSupplies(mutableListOfSupplies)
             }
         }
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/Extent.kt b/behavior-graph/src/main/kotlin/behaviorgraph/Extent.kt
@@ -61,7 +61,7 @@ open class Extent<ExtentContext: Any> @JvmOverloads constructor(val graph: Graph
         if (lifetime == null) {
             lifetime = ExtentLifetime(this)
         }
-        lifetime!!.unify(extent)
+        lifetime?.unify(extent)
     }
 
     /**
@@ -71,14 +71,14 @@ open class Extent<ExtentContext: Any> @JvmOverloads constructor(val graph: Graph
         if (this.lifetime == null) {
             lifetime = ExtentLifetime(this)
         }
-        lifetime!!.addChild(extent)
+        lifetime?.addChild(extent)
     }
 
     internal fun hasCompatibleLifetime(extent: Extent<*>): Boolean {
         if (this == extent) {
             return true
         } else if (lifetime != null) {
-            return lifetime!!.hasCompatibleLifetime(extent.lifetime)
+            return lifetime?.hasCompatibleLifetime(extent.lifetime) ?: false
         } else {
             return false
         }
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/ExtentLifetime.kt b/behavior-graph/src/main/kotlin/behaviorgraph/ExtentLifetime.kt
@@ -31,11 +31,11 @@ internal class ExtentLifetime(
         if (extent.lifetime != null) {
             // merge existing lifetimes and children into one lifetime heirarchy
             // move children first
-            extent.lifetime!!.children?.forEach {(lifetime, _) ->
+            extent.lifetime?.children?.forEach {(lifetime, _) ->
                 addChildLifetime(lifetime)
             }
             // then make any extents in other lifetime part of this one
-            extent.lifetime!!.extents.forEach { (it, _) ->
+            extent.lifetime?.extents?.forEach { (it, _) ->
                 it.lifetime = this
                 extents[it] = true
             }
@@ -49,7 +49,9 @@ internal class ExtentLifetime(
         if (extent.lifetime == null) {
             extent.lifetime = ExtentLifetime(extent)
         }
-        addChildLifetime(extent.lifetime!!)
+        extent.lifetime?.let {
+            addChildLifetime(it)
+        }
     }
 
     fun addChildLifetime(lifetime: ExtentLifetime) {
@@ -77,9 +79,10 @@ internal class ExtentLifetime(
             return true
         } else if (lifetime != null) {
             // parents
-            if (parent != null) {
+            val thisParent = parent
+            if (thisParent != null) {
                 // parent is a weak reference so we get it here
-                val refParent = parent!!.get()
+                val refParent = thisParent.get()
                 if (refParent != null) {
                     return refParent.hasCompatibleLifetime(lifetime)
                 }
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/Graph.kt b/behavior-graph/src/main/kotlin/behaviorgraph/Graph.kt
@@ -139,12 +139,13 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                 // Check that an action wasn't created from inside another action or behavior.
                 // It is easy to accidentally do an updateWithAction inside a behavior or action
                 // We want to alert the programmer to that mistake.
-                val wrongAction = eventLoopState != null &&
-                        eventLoopState!!.thread == Thread.currentThread() &&
-                        (eventLoopState!!.phase == EventLoopPhase.Action || eventLoopState!!.phase == EventLoopPhase.Updates)
-                assert(
-                    !wrongAction,
-                    { "Action cannot be created directly inside another action or behavior. Consider wrapping it in a side effect block." })
+                eventLoopState?.let {
+                    val wrongAction = it.thread == Thread.currentThread() &&
+                            (it.phase == EventLoopPhase.Action || it.phase == EventLoopPhase.Updates)
+                    assert(
+                        !wrongAction,
+                        { "Action cannot be created directly inside another action or behavior. Consider wrapping it in a side effect block." })
+                }
                 // queue up the action and start the event loop if one isn't already running
                 actions.addLast(action)
                 if (currentEvent == null) {
@@ -180,8 +181,8 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                     modifiedSupplyBehaviors.size > 0 ||
                     needsOrdering.size > 0
                 ) {
-                    eventLoopState!!.phase = EventLoopPhase.Updates
-                    val sequence = this.currentEvent!!.sequence
+                    eventLoopState?.phase = EventLoopPhase.Updates
+                    val sequence: Long = this.currentEvent?.sequence ?: 0
                     addUntrackedBehaviors()
                     addUntrackedSupplies()
                     addUntrackedDemands(sequence)
@@ -203,9 +204,9 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                 }
                 if (effects.isNotEmpty()) {
                     val effect = this.effects.removeFirst()
-                    eventLoopState!!.phase = EventLoopPhase.SideEffects
-                    eventLoopState!!.currentSideEffect = effect
-                    sideEffectExecutor!!.execute(effect)
+                    eventLoopState?.phase = EventLoopPhase.SideEffects
+                    eventLoopState?.currentSideEffect = effect
+                    sideEffectExecutor.execute(effect)
                     if (eventLoopState != null) {
                         // side effect could create a synchronous action which would create a nested event loop
                         // which would clear out any existing event loop states
@@ -215,13 +216,13 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                 }
 
                 currentEvent?.let { aCurrentEvent ->
-                    val eventAction = eventLoopState!!.action
+                    val eventAction = eventLoopState?.action
                     clearTransients()
                     lastEvent = aCurrentEvent
                     currentEvent = null
                     eventLoopState = null
                     currentBehavior = null
-                    eventAction.complete()
+                    eventAction?.complete()
                 }
 
                 if (actions.isNotEmpty()) {
@@ -231,7 +232,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                     )
                     this.currentEvent = newEvent
                     eventLoopState = EventLoopState(action)
-                    eventLoopState!!.phase = EventLoopPhase.Action
+                    eventLoopState?.phase = EventLoopPhase.Action
                     action.runAction()
                     continue
                 }
@@ -262,7 +263,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
         val needAdding: MutableSet<Extent<*>> = mutableSetOf()
         for (added in extentsAdded) {
             if (added.lifetime != null) {
-                for (ext in added.lifetime!!.getAllContainingExtents()) {
+                for (ext in added.lifetime?.getAllContainingExtents() ?: listOf()) {
                     if (ext.addedToGraphWhen == null) {
                         needAdding.add(ext)
                     }
@@ -279,7 +280,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
         val needRemoving: MutableSet<Extent<*>> = mutableSetOf()
         for (removed in extentsRemoved) {
             if (removed.lifetime != null) {
-                for (ext in removed.lifetime!!.getAllContainedExtents()) {
+                for (ext in removed.lifetime?.getAllContainedExtents() ?: listOf()) {
                     if (ext.addedToGraphWhen != null) {
                         needRemoving.add(ext)
                     }
@@ -300,7 +301,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                         }
                     }
                 }
-                if (resource.suppliedBy != null && resource.suppliedBy!!.extent.addedToGraphWhen != null) {
+                if (resource.suppliedBy != null && resource.suppliedBy?.extent?.addedToGraphWhen != null) {
                     assert(false) {
                         "Remaining behaviors should remove dynamicSupplies to removed resources. \nRemaining Behavior=${resource.suppliedBy} \nRemoved resource=$resource"
                     }
@@ -322,12 +323,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
 
     internal fun resourceTouched(resource: Resource) {
         this.currentEvent?.let { aCurrentEvent ->
-            if (eventLoopState != null && eventLoopState!!.phase == EventLoopPhase.Action) {
-                eventLoopState!!.actionUpdates.add(resource)
+            if (eventLoopState != null && eventLoopState?.phase == EventLoopPhase.Action) {
+                eventLoopState?.actionUpdates?.add(resource)
             }
             for (subsequent in resource.subsequents) {
                 val isOrderingDemand =
-                    subsequent.orderingDemands != null && subsequent.orderingDemands!!.contains(resource)
+                    subsequent.orderingDemands != null && subsequent.orderingDemands?.contains(resource) ?: false
                 if (!isOrderingDemand) {
                     activateBehavior(subsequent, aCurrentEvent.sequence)
                 }
@@ -336,7 +337,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
     }
 
     private fun activateBehavior(behavior: Behavior<*>, sequence: Long) {
-        if (behavior.enqueuedWhen == null || behavior.enqueuedWhen!! < sequence) {
+        if (behavior.enqueuedWhen == null || (behavior.enqueuedWhen ?: 0) < sequence) {
             behavior.enqueuedWhen = sequence
             activatedBehaviors.add(behavior)
         }
@@ -370,7 +371,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
             assert(false) {
                 "You've created a side effect from an alternate thread while another is running. Side effects should be created inside behaviors only."
             }
-        } else if (eventLoopState!!.phase == EventLoopPhase.SideEffects) {
+        } else if (eventLoopState?.phase == EventLoopPhase.SideEffects) {
             assert(false) {
                 "You've created a side effect inside another side effect. Side effects should be created inside behaviors. Is this a mistake?"
             }
@@ -401,13 +402,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
             }
 
             val allUntrackedSupplies: MutableSet<Resource> = mutableSetOf()
-            if (behavior.untrackedSupplies != null) {
-                allUntrackedSupplies.addAll(behavior.untrackedSupplies!!)
+            behavior.untrackedSupplies?.let {
+                allUntrackedSupplies.addAll(it)
             }
-            if (behavior.untrackedDynamicSupplies != null) {
-                allUntrackedSupplies.addAll(behavior.untrackedDynamicSupplies!!)
+            behavior.untrackedDynamicSupplies?.let {
+                allUntrackedSupplies.addAll(it)
             }
-
             behavior.supplies?.forEach { it.suppliedBy = null }
 
             behavior.supplies = allUntrackedSupplies
@@ -446,11 +446,11 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
             }
 
             val allUntrackedDemands: MutableSet<Demandable> = mutableSetOf()
-            if (behavior.untrackedDemands != null) {
-                allUntrackedDemands.addAll(behavior.untrackedDemands!!)
+            behavior.untrackedDemands?.let {
+                allUntrackedDemands.addAll(it)
             }
-            if (behavior.untrackedDynamicDemands != null) {
-                allUntrackedDemands.addAll(behavior.untrackedDynamicDemands!!)
+            behavior.untrackedDynamicDemands?.let {
+                allUntrackedDemands.addAll(it)
             }
 
             var removedDemands: MutableList<Resource>? = null
@@ -459,7 +459,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                     if (removedDemands == null) {
                         removedDemands = mutableListOf()
                     }
-                    removedDemands!!.add(demand)
+                    removedDemands?.add(demand)
                 }
             }
 
@@ -471,7 +471,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                         "Cannot demand a resource that hasn't been added to the graph. Demanding behavior=$behavior \nDemand=$untrackedDemand"
                     }
                 }
-                if (behavior.demands == null || !behavior.demands!!.contains(untrackedDemand)) {
+                if (behavior.demands == null || !(behavior.demands?.contains(untrackedDemand) ?: false)) {
                     if (addedDemands == null) {
                         addedDemands = mutableListOf()
                     }
@@ -502,12 +502,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
                 if (newDemands == null) {
                     newDemands = mutableSetOf()
                 }
-                newDemands!!.add(link.resource)
+                newDemands?.add(link.resource)
                 if (link.type == LinkType.Order) {
                     if (orderingDemands == null) {
                         orderingDemands = mutableSetOf()
                     }
-                    orderingDemands!!.add(link.resource)
+                    orderingDemands?.add(link.resource)
                 }
             }
             behavior.demands = newDemands
@@ -721,8 +721,8 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
 
         if (validateLifetimes) {
             if (extent.lifetime != null) {
-                if (extent.lifetime!!.addedToGraphWhen == null) {
-                    extent.lifetime!!.addedToGraphWhen = currentEvent!!.sequence
+                if (extent.lifetime?.addedToGraphWhen == null) {
+                    extent.lifetime?.addedToGraphWhen = currentEvent?.sequence
                 }
             }
             val refParent = extent.lifetime?.parent?.get()
@@ -734,9 +734,9 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
             }
         }
 
-        extent.addedToGraphWhen = currentEvent!!.sequence
+        extent.addedToGraphWhen = currentEvent?.sequence
         extentsAdded.add(extent)
-        activateBehavior(extent.didAddBehavior, currentEvent!!.sequence)
+        activateBehavior(extent.didAddBehavior, currentEvent?.sequence ?: 0)
         for (behavior in extent.behaviors) {
             addBehavior(behavior)
         }
@@ -751,24 +751,24 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =
         }
         extentsRemoved.add(extent)
         for (behavior in extent.behaviors) {
-            removeBehavior(behavior, currentEvent!!.sequence)
+            removeBehavior(behavior, currentEvent?.sequence ?: 0)
         }
         extent.addedToGraphWhen = null
     }
 
     override fun toString(): String {
         return buildString {
             if (currentEvent != null) {
-                append(String.format("Current Event: %d\n", currentEvent!!.sequence))
+                append(String.format("Current Event: %d\n", currentEvent?.sequence ?: 0))
             } else {
                 append("No current event")
             }
-            if (eventLoopState != null) {
-                append(eventLoopState!!.toString())
+            eventLoopState?.let {
+                append(it.toString())
                 append("\n")
             }
-            if (currentBehavior != null) {
-                append(currentBehavior!!.toString())
+            currentBehavior?.let {
+                append(it.toString())
             }
         }
     }
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/Resource.kt b/behavior-graph/src/main/kotlin/behaviorgraph/Resource.kt
@@ -53,7 +53,8 @@ open class Resource @JvmOverloads constructor(val extent: Extent<*>, var debugNa
     internal fun assertValidAccessor() {
         if (!graph.validateDependencies) { return }
         // allow access to state from alternate threads while running
-        if (graph.eventLoopState != null && graph.eventLoopState!!.thread != Thread.currentThread()) { return }
+        val eventLoopThread = graph.eventLoopState?.thread
+        if (graph.eventLoopState != null && eventLoopThread != Thread.currentThread()) { return }
         val currentBehavior = graph.currentBehavior
         if (currentBehavior != null && currentBehavior != suppliedBy && !(currentBehavior.demands?.contains(this) ?: false)) {
             assert(false) {
diff --git a/behavior-graph/src/main/kotlin/behaviorgraph/State.kt b/behavior-graph/src/main/kotlin/behaviorgraph/State.kt
@@ -88,12 +88,15 @@ class State<T> @JvmOverloads constructor(extent: Extent<*>, initialState: T, deb
      */
     fun updateForce(newValue: T) {
         assertValidUpdater()
-        if (graph.currentEvent != null && currentState.event.sequence < graph.currentEvent!!.sequence) {
+        val thisSequence = graph.currentEvent?.sequence ?: 0
+        if (graph.currentEvent != null && currentState.event.sequence < thisSequence) {
             // this check prevents updating priorState if we are updated multiple times in same behavior
             priorStateDuringEvent = currentState
         }
 
-        currentState = StateHistory(newValue, this.graph.currentEvent!!)
+        this.graph.currentEvent?.let {
+            currentState = StateHistory(newValue, it)
+        }
         this.graph.resourceTouched(this)
         this.graph.trackTransient(this)
     }
@@ -124,7 +127,7 @@ class State<T> @JvmOverloads constructor(extent: Extent<*>, initialState: T, deb
      */
     fun justUpdatedFrom(fromValue: T): Boolean {
         return justUpdated &&
-            (priorStateDuringEvent!!.value == fromValue)
+            (priorStateDuringEvent?.value == fromValue)
     }
 
     /**

Original file line number	Diff line number	Diff line change
`@@ -163,13 +163,13 @@ class BehaviorBuilder<T: Any>(`
`163`	`163`	`val demands: MutableList<Demandable> = mutableListOf()`
`164`	`164`	`dynamicDemandSwitches?.let { demands.addAll(it) }`
`165`	`165`	`if (dynamicDemandRelinkingOrder == RelinkingOrder.RelinkingOrderPrior) {`
`166`		`- supplies = listOf(dynamicDemandResource!!)`
	`166`	`+ dynamicDemandResource?.let { supplies = listOf(it) }`
`167`	`167`	`} else {`
`168`		`- demands.add(dynamicDemandResource!!)`
	`168`	`+ dynamicDemandResource?.let { demands.add(it) }`
`169`	`169`	`}`
`170`	`170`	`Behavior(extent, demands, supplies) {`
`171`	`171`	`val mutableListOfDemands = mutableListOf<Demandable?>()`
`172`		`- dynamicDemandLinks!!.invoke(it, mutableListOfDemands)`
	`172`	`+ dynamicDemandLinks?.invoke(it, mutableListOfDemands)`
`173`	`173`	`mainBehavior.setDynamicDemands(mutableListOfDemands)`
`174`	`174`	`}`
`175`	`175`	`}`
`@@ -179,13 +179,13 @@ class BehaviorBuilder<T: Any>(`
`179`	`179`	`val demands: MutableList<Demandable> = mutableListOf()`
`180`	`180`	`dynamicSupplySwitches?.let { demands.addAll(it) }`
`181`	`181`	`if (dynamicSupplyRelinkingOrder == RelinkingOrder.RelinkingOrderPrior) {`
`182`		`- supplies = listOf(dynamicSupplyResource!!)`
	`182`	`+ dynamicSupplyResource?.let { supplies = listOf(dynamicSupplyResource) }`
`183`	`183`	`} else {`
`184`		`- demands.add(dynamicSupplyResource!!)`
	`184`	`+ dynamicSupplyResource?.let { demands.add(dynamicSupplyResource) }`
`185`	`185`	`}`
`186`	`186`	`Behavior(extent, demands, supplies) {`
`187`	`187`	`val mutableListOfSupplies = mutableListOf<Resource?>()`
`188`		`- dynamicSupplyLinks!!.invoke(it, mutableListOfSupplies)`
	`188`	`+ dynamicSupplyLinks?.invoke(it, mutableListOfSupplies)`
`189`	`189`	`mainBehavior.setDynamicSupplies(mutableListOfSupplies)`
`190`	`190`	`}`
`191`	`191`	`}`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ open class Extent<ExtentContext: Any> @JvmOverloads constructor(val graph: Graph`
`61`	`61`	`if (lifetime == null) {`
`62`	`62`	`lifetime = ExtentLifetime(this)`
`63`	`63`	`}`
`64`		`- lifetime!!.unify(extent)`
	`64`	`+ lifetime?.unify(extent)`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/**`
`@@ -71,14 +71,14 @@ open class Extent<ExtentContext: Any> @JvmOverloads constructor(val graph: Graph`
`71`	`71`	`if (this.lifetime == null) {`
`72`	`72`	`lifetime = ExtentLifetime(this)`
`73`	`73`	`}`
`74`		`- lifetime!!.addChild(extent)`
	`74`	`+ lifetime?.addChild(extent)`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`internal fun hasCompatibleLifetime(extent: Extent<*>): Boolean {`
`78`	`78`	`if (this == extent) {`
`79`	`79`	`return true`
`80`	`80`	`} else if (lifetime != null) {`
`81`		`- return lifetime!!.hasCompatibleLifetime(extent.lifetime)`
	`81`	`+ return lifetime?.hasCompatibleLifetime(extent.lifetime) ?: false`
`82`	`82`	`} else {`
`83`	`83`	`return false`
`84`	`84`	`}`
Original file line number	Diff line number	Diff line change
`@@ -139,12 +139,13 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`139`	`139`	`// Check that an action wasn't created from inside another action or behavior.`
`140`	`140`	`// It is easy to accidentally do an updateWithAction inside a behavior or action`
`141`	`141`	`// We want to alert the programmer to that mistake.`
`142`		`- val wrongAction = eventLoopState != null &&`
`143`		`- eventLoopState!!.thread == Thread.currentThread() &&`
`144`		`- (eventLoopState!!.phase == EventLoopPhase.Action \|\| eventLoopState!!.phase == EventLoopPhase.Updates)`
`145`		`- assert(`
`146`		`- !wrongAction,`
`147`		`- { "Action cannot be created directly inside another action or behavior. Consider wrapping it in a side effect block." })`
	`142`	`+ eventLoopState?.let {`
	`143`	`+ val wrongAction = it.thread == Thread.currentThread() &&`
	`144`	`+ (it.phase == EventLoopPhase.Action \|\| it.phase == EventLoopPhase.Updates)`
	`145`	`+ assert(`
	`146`	`+ !wrongAction,`
	`147`	`+ { "Action cannot be created directly inside another action or behavior. Consider wrapping it in a side effect block." })`
	`148`	`+ }`
`148`	`149`	`// queue up the action and start the event loop if one isn't already running`
`149`	`150`	`actions.addLast(action)`
`150`	`151`	`if (currentEvent == null) {`
`@@ -180,8 +181,8 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`180`	`181`	`modifiedSupplyBehaviors.size > 0 \|\|`
`181`	`182`	`needsOrdering.size > 0`
`182`	`183`	`) {`
`183`		`- eventLoopState!!.phase = EventLoopPhase.Updates`
`184`		`- val sequence = this.currentEvent!!.sequence`
	`184`	`+ eventLoopState?.phase = EventLoopPhase.Updates`
	`185`	`+ val sequence: Long = this.currentEvent?.sequence ?: 0`
`185`	`186`	`addUntrackedBehaviors()`
`186`	`187`	`addUntrackedSupplies()`
`187`	`188`	`addUntrackedDemands(sequence)`
`@@ -203,9 +204,9 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`203`	`204`	`}`
`204`	`205`	`if (effects.isNotEmpty()) {`
`205`	`206`	`val effect = this.effects.removeFirst()`
`206`		`- eventLoopState!!.phase = EventLoopPhase.SideEffects`
`207`		`- eventLoopState!!.currentSideEffect = effect`
`208`		`- sideEffectExecutor!!.execute(effect)`
	`207`	`+ eventLoopState?.phase = EventLoopPhase.SideEffects`
	`208`	`+ eventLoopState?.currentSideEffect = effect`
	`209`	`+ sideEffectExecutor.execute(effect)`
`209`	`210`	`if (eventLoopState != null) {`
`210`	`211`	`// side effect could create a synchronous action which would create a nested event loop`
`211`	`212`	`// which would clear out any existing event loop states`
`@@ -215,13 +216,13 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`215`	`216`	`}`
`216`	`217`
`217`	`218`	`currentEvent?.let { aCurrentEvent ->`
`218`		`- val eventAction = eventLoopState!!.action`
	`219`	`+ val eventAction = eventLoopState?.action`
`219`	`220`	`clearTransients()`
`220`	`221`	`lastEvent = aCurrentEvent`
`221`	`222`	`currentEvent = null`
`222`	`223`	`eventLoopState = null`
`223`	`224`	`currentBehavior = null`
`224`		`- eventAction.complete()`
	`225`	`+ eventAction?.complete()`
`225`	`226`	`}`
`226`	`227`
`227`	`228`	`if (actions.isNotEmpty()) {`
`@@ -231,7 +232,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`231`	`232`	`)`
`232`	`233`	`this.currentEvent = newEvent`
`233`	`234`	`eventLoopState = EventLoopState(action)`
`234`		`- eventLoopState!!.phase = EventLoopPhase.Action`
	`235`	`+ eventLoopState?.phase = EventLoopPhase.Action`
`235`	`236`	`action.runAction()`
`236`	`237`	`continue`
`237`	`238`	`}`
`@@ -262,7 +263,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`262`	`263`	`val needAdding: MutableSet<Extent<*>> = mutableSetOf()`
`263`	`264`	`for (added in extentsAdded) {`
`264`	`265`	`if (added.lifetime != null) {`
`265`		`- for (ext in added.lifetime!!.getAllContainingExtents()) {`
	`266`	`+ for (ext in added.lifetime?.getAllContainingExtents() ?: listOf()) {`
`266`	`267`	`if (ext.addedToGraphWhen == null) {`
`267`	`268`	`needAdding.add(ext)`
`268`	`269`	`}`
`@@ -279,7 +280,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`279`	`280`	`val needRemoving: MutableSet<Extent<*>> = mutableSetOf()`
`280`	`281`	`for (removed in extentsRemoved) {`
`281`	`282`	`if (removed.lifetime != null) {`
`282`		`- for (ext in removed.lifetime!!.getAllContainedExtents()) {`
	`283`	`+ for (ext in removed.lifetime?.getAllContainedExtents() ?: listOf()) {`
`283`	`284`	`if (ext.addedToGraphWhen != null) {`
`284`	`285`	`needRemoving.add(ext)`
`285`	`286`	`}`
`@@ -300,7 +301,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`300`	`301`	`}`
`301`	`302`	`}`
`302`	`303`	`}`
`303`		`- if (resource.suppliedBy != null && resource.suppliedBy!!.extent.addedToGraphWhen != null) {`
	`304`	`+ if (resource.suppliedBy != null && resource.suppliedBy?.extent?.addedToGraphWhen != null) {`
`304`	`305`	`assert(false) {`
`305`	`306`	`"Remaining behaviors should remove dynamicSupplies to removed resources. \nRemaining Behavior=${resource.suppliedBy} \nRemoved resource=$resource"`
`306`	`307`	`}`
`@@ -322,12 +323,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`322`	`323`
`323`	`324`	`internal fun resourceTouched(resource: Resource) {`
`324`	`325`	`this.currentEvent?.let { aCurrentEvent ->`
`325`		`- if (eventLoopState != null && eventLoopState!!.phase == EventLoopPhase.Action) {`
`326`		`- eventLoopState!!.actionUpdates.add(resource)`
	`326`	`+ if (eventLoopState != null && eventLoopState?.phase == EventLoopPhase.Action) {`
	`327`	`+ eventLoopState?.actionUpdates?.add(resource)`
`327`	`328`	`}`
`328`	`329`	`for (subsequent in resource.subsequents) {`
`329`	`330`	`val isOrderingDemand =`
`330`		`- subsequent.orderingDemands != null && subsequent.orderingDemands!!.contains(resource)`
	`331`	`+ subsequent.orderingDemands != null && subsequent.orderingDemands?.contains(resource) ?: false`
`331`	`332`	`if (!isOrderingDemand) {`
`332`	`333`	`activateBehavior(subsequent, aCurrentEvent.sequence)`
`333`	`334`	`}`
`@@ -336,7 +337,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`336`	`337`	`}`
`337`	`338`
`338`	`339`	`private fun activateBehavior(behavior: Behavior<*>, sequence: Long) {`
`339`		`- if (behavior.enqueuedWhen == null \|\| behavior.enqueuedWhen!! < sequence) {`
	`340`	`+ if (behavior.enqueuedWhen == null \|\| (behavior.enqueuedWhen ?: 0) < sequence) {`
`340`	`341`	`behavior.enqueuedWhen = sequence`
`341`	`342`	`activatedBehaviors.add(behavior)`
`342`	`343`	`}`
`@@ -370,7 +371,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`370`	`371`	`assert(false) {`
`371`	`372`	`"You've created a side effect from an alternate thread while another is running. Side effects should be created inside behaviors only."`
`372`	`373`	`}`
`373`		`- } else if (eventLoopState!!.phase == EventLoopPhase.SideEffects) {`
	`374`	`+ } else if (eventLoopState?.phase == EventLoopPhase.SideEffects) {`
`374`	`375`	`assert(false) {`
`375`	`376`	`"You've created a side effect inside another side effect. Side effects should be created inside behaviors. Is this a mistake?"`
`376`	`377`	`}`
`@@ -401,13 +402,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`401`	`402`	`}`
`402`	`403`
`403`	`404`	`val allUntrackedSupplies: MutableSet<Resource> = mutableSetOf()`
`404`		`- if (behavior.untrackedSupplies != null) {`
`405`		`- allUntrackedSupplies.addAll(behavior.untrackedSupplies!!)`
	`405`	`+ behavior.untrackedSupplies?.let {`
	`406`	`+ allUntrackedSupplies.addAll(it)`
`406`	`407`	`}`
`407`		`- if (behavior.untrackedDynamicSupplies != null) {`
`408`		`- allUntrackedSupplies.addAll(behavior.untrackedDynamicSupplies!!)`
	`408`	`+ behavior.untrackedDynamicSupplies?.let {`
	`409`	`+ allUntrackedSupplies.addAll(it)`
`409`	`410`	`}`
`410`		`-`
`411`	`411`	`behavior.supplies?.forEach { it.suppliedBy = null }`
`412`	`412`
`413`	`413`	`behavior.supplies = allUntrackedSupplies`
`@@ -446,11 +446,11 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`446`	`446`	`}`
`447`	`447`
`448`	`448`	`val allUntrackedDemands: MutableSet<Demandable> = mutableSetOf()`
`449`		`- if (behavior.untrackedDemands != null) {`
`450`		`- allUntrackedDemands.addAll(behavior.untrackedDemands!!)`
	`449`	`+ behavior.untrackedDemands?.let {`
	`450`	`+ allUntrackedDemands.addAll(it)`
`451`	`451`	`}`
`452`		`- if (behavior.untrackedDynamicDemands != null) {`
`453`		`- allUntrackedDemands.addAll(behavior.untrackedDynamicDemands!!)`
	`452`	`+ behavior.untrackedDynamicDemands?.let {`
	`453`	`+ allUntrackedDemands.addAll(it)`
`454`	`454`	`}`
`455`	`455`
`456`	`456`	`var removedDemands: MutableList<Resource>? = null`
`@@ -459,7 +459,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`459`	`459`	`if (removedDemands == null) {`
`460`	`460`	`removedDemands = mutableListOf()`
`461`	`461`	`}`
`462`		`- removedDemands!!.add(demand)`
	`462`	`+ removedDemands?.add(demand)`
`463`	`463`	`}`
`464`	`464`	`}`
`465`	`465`
`@@ -471,7 +471,7 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`471`	`471`	`"Cannot demand a resource that hasn't been added to the graph. Demanding behavior=$behavior \nDemand=$untrackedDemand"`
`472`	`472`	`}`
`473`	`473`	`}`
`474`		`- if (behavior.demands == null \|\| !behavior.demands!!.contains(untrackedDemand)) {`
	`474`	`+ if (behavior.demands == null \|\| !(behavior.demands?.contains(untrackedDemand) ?: false)) {`
`475`	`475`	`if (addedDemands == null) {`
`476`	`476`	`addedDemands = mutableListOf()`
`477`	`477`	`}`
`@@ -502,12 +502,12 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`502`	`502`	`if (newDemands == null) {`
`503`	`503`	`newDemands = mutableSetOf()`
`504`	`504`	`}`
`505`		`- newDemands!!.add(link.resource)`
	`505`	`+ newDemands?.add(link.resource)`
`506`	`506`	`if (link.type == LinkType.Order) {`
`507`	`507`	`if (orderingDemands == null) {`
`508`	`508`	`orderingDemands = mutableSetOf()`
`509`	`509`	`}`
`510`		`- orderingDemands!!.add(link.resource)`
	`510`	`+ orderingDemands?.add(link.resource)`
`511`	`511`	`}`
`512`	`512`	`}`
`513`	`513`	`behavior.demands = newDemands`
`@@ -721,8 +721,8 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`721`	`721`
`722`	`722`	`if (validateLifetimes) {`
`723`	`723`	`if (extent.lifetime != null) {`
`724`		`- if (extent.lifetime!!.addedToGraphWhen == null) {`
`725`		`- extent.lifetime!!.addedToGraphWhen = currentEvent!!.sequence`
	`724`	`+ if (extent.lifetime?.addedToGraphWhen == null) {`
	`725`	`+ extent.lifetime?.addedToGraphWhen = currentEvent?.sequence`
`726`	`726`	`}`
`727`	`727`	`}`
`728`	`728`	`val refParent = extent.lifetime?.parent?.get()`
`@@ -734,9 +734,9 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`734`	`734`	`}`
`735`	`735`	`}`
`736`	`736`
`737`		`- extent.addedToGraphWhen = currentEvent!!.sequence`
	`737`	`+ extent.addedToGraphWhen = currentEvent?.sequence`
`738`	`738`	`extentsAdded.add(extent)`
`739`		`- activateBehavior(extent.didAddBehavior, currentEvent!!.sequence)`
	`739`	`+ activateBehavior(extent.didAddBehavior, currentEvent?.sequence ?: 0)`
`740`	`740`	`for (behavior in extent.behaviors) {`
`741`	`741`	`addBehavior(behavior)`
`742`	`742`	`}`
`@@ -751,24 +751,24 @@ class Graph @JvmOverloads constructor(private val dateProvider: DateProvider? =`
`751`	`751`	`}`
`752`	`752`	`extentsRemoved.add(extent)`
`753`	`753`	`for (behavior in extent.behaviors) {`
`754`		`- removeBehavior(behavior, currentEvent!!.sequence)`
	`754`	`+ removeBehavior(behavior, currentEvent?.sequence ?: 0)`
`755`	`755`	`}`
`756`	`756`	`extent.addedToGraphWhen = null`
`757`	`757`	`}`
`758`	`758`
`759`	`759`	`override fun toString(): String {`
`760`	`760`	`return buildString {`
`761`	`761`	`if (currentEvent != null) {`
`762`		`- append(String.format("Current Event: %d\n", currentEvent!!.sequence))`
	`762`	`+ append(String.format("Current Event: %d\n", currentEvent?.sequence ?: 0))`
`763`	`763`	`} else {`
`764`	`764`	`append("No current event")`
`765`	`765`	`}`
`766`		`- if (eventLoopState != null) {`
`767`		`- append(eventLoopState!!.toString())`
	`766`	`+ eventLoopState?.let {`
	`767`	`+ append(it.toString())`
`768`	`768`	`append("\n")`
`769`	`769`	`}`
`770`		`- if (currentBehavior != null) {`
`771`		`- append(currentBehavior!!.toString())`
	`770`	`+ currentBehavior?.let {`
	`771`	`+ append(it.toString())`
`772`	`772`	`}`
`773`	`773`	`}`
`774`	`774`	`}`