Renamed TransactionResolution to StatePosition.

Author: MrMatthewLayton

gradle.properties

@@ -1,5 +1,5 @@
 name=onixlabs-corda-core
 group=io.onixlabs
-version=4.0.0-rc3
+version=4.0.0-rc4
 onixlabs.development.jarsign.keystore=../lib/onixlabs.development.pkcs12
 onixlabs.development.jarsign.password=5891f47942424d2acbe108691fdb5ba258712fca7e4762be4327241ebf3dbfa3

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractPluralResolvable.kt

@@ -61,16 +61,10 @@ abstract class AbstractPluralResolvable<T> : PluralResolvable<T> where T : Contr
      * Resolves a [ContractState] using a [LedgerTransaction] instance.
      *
      * @param transaction The [LedgerTransaction] instance to use to resolve the state.
-     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @param position The position of the [ContractState]  instances to resolve in the transaction.
      * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
      */
-    override fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): List<StateAndRef<T>> {
-        val states = when (resolution) {
-            TransactionResolution.INPUT -> transaction.inRefsOfType(contractStateType)
-            TransactionResolution.OUTPUT -> transaction.outRefsOfType(contractStateType)
-            TransactionResolution.REFERENCE -> transaction.referenceInputRefsOfType(contractStateType)
-        }
-
-        return states.filter { isPointingTo(it) }
+    override fun resolve(transaction: LedgerTransaction, position: StatePosition): List<StateAndRef<T>> {
+        return position.getStateAndRefs(transaction, contractStateType).filter { isPointingTo(it) }
     }
 }

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/AbstractSingularResolvable.kt

@@ -61,16 +61,10 @@ abstract class AbstractSingularResolvable<T> : SingularResolvable<T> where T : C
      * Resolves a [ContractState] using a [LedgerTransaction] instance.
      *
      * @param transaction The [LedgerTransaction] instance to use to resolve the state.
-     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @param position The position of the [ContractState] instance to resolve in the transaction.
      * @return Returns the resolved [ContractState], or null if no matching state is found.
      */
-    override fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): StateAndRef<T>? {
-        val states = when (resolution) {
-            TransactionResolution.INPUT -> transaction.inRefsOfType(contractStateType)
-            TransactionResolution.OUTPUT -> transaction.outRefsOfType(contractStateType)
-            TransactionResolution.REFERENCE -> transaction.referenceInputRefsOfType(contractStateType)
-        }
-
-        return states.singleOrNull { isPointingTo(it) }
+    override fun resolve(transaction: LedgerTransaction, position: StatePosition): StateAndRef<T>? {
+        return position.getStateAndRefs(transaction, contractStateType).singleOrNull { isPointingTo(it) }
     }
 }

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/Extensions.SingularResolvable.kt

@@ -52,12 +52,12 @@ fun <T : ContractState> SingularResolvable<T>.resolveOrThrow(
  * Resolves a [ContractState] using a [LedgerTransaction] instance.
  *
  * @param transaction The [LedgerTransaction] instance to use to resolve the state.
- * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+ * @param position The position of the [ContractState] instance to resolve in the transaction.
  * @param message The exception message to throw if the state cannot be resolved.
  * @return Returns the resolved [ContractState], or throws an exception if the state cannot be resolved.
  */
 fun <T : ContractState> SingularResolvable<T>.resolveOrThrow(
     transaction: LedgerTransaction,
-    resolution: TransactionResolution,
+    position: StatePosition,
     message: () -> String = { MESSAGE }
-): StateAndRef<T> = resolve(transaction, resolution) ?: throw IllegalArgumentException(message())
+): StateAndRef<T> = resolve(transaction, position) ?: throw IllegalArgumentException(message())

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/PluralResolvable.kt

@@ -49,10 +49,10 @@ interface PluralResolvable<T> where T : ContractState {
      * Resolves a [ContractState] using a [LedgerTransaction] instance.
      *
      * @param transaction The [LedgerTransaction] instance to use to resolve the state.
-     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @param position The position of the [ContractState] instances to resolve in the transaction.
      * @return Returns a list of resolved [ContractState] elements, or an empty list if no matching state is found.
      */
-    fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): List<StateAndRef<T>>
+    fun resolve(transaction: LedgerTransaction, position: StatePosition): List<StateAndRef<T>>
 
     /**
      * Determines whether this [PluralResolvable] is pointing to the specified [StateAndRef] instance.

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/SingularResolvable.kt

@@ -49,10 +49,10 @@ interface SingularResolvable<T> where T : ContractState {
      * Resolves a [ContractState] using a [LedgerTransaction] instance.
      *
      * @param transaction The [LedgerTransaction] instance to use to resolve the state.
-     * @param resolution The transaction resolution method to use to resolve the [ContractState] instance.
+     * @param position The position of the [ContractState]  instance to resolve in the transaction.
      * @return Returns the resolved [ContractState], or null if no matching state is found.
      */
-    fun resolve(transaction: LedgerTransaction, resolution: TransactionResolution): StateAndRef<T>?
+    fun resolve(transaction: LedgerTransaction, position: StatePosition): StateAndRef<T>?
 
     /**
      * Determines whether this [SingularResolvable] is pointing to the specified [StateAndRef] instance.

onixlabs-corda-core-contract/src/main/kotlin/io/onixlabs/corda/core/contract/StatePosition.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2020-2022 ONIXLabs
+ *
+ * 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
+ *
+ *    http://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 io.onixlabs.corda.core.contract
+
+import io.onixlabs.corda.core.contract.StatePosition.*
+import net.corda.core.contracts.ContractState
+import net.corda.core.contracts.StateAndRef
+import net.corda.core.serialization.CordaSerializable
+import net.corda.core.transactions.LedgerTransaction
+
+/**
+ * Determines the position of a state within a transaction.
+ *
+ * @property INPUT The state is an input state in the transaction.
+ * @property OUTPUT The state is an output state in the transaction.
+ * @property REFERENCE The state is a reference state in the transaction.
+ */
+@CordaSerializable
+enum class StatePosition {
+    INPUT,
+    OUTPUT,
+    REFERENCE;
+
+    /**
+     * Obtains a [List] of [StateAndRef] of type [T] from the specified [LedgerTransaction].
+     *
+     * @param T The underlying [ContractState] type to obtain from the transaction.
+     * @param transaction The [LedgerTransaction] from which to obtain [StateAndRef] instances of type [T].
+     * @param type The [ContractState] type to obtain from the transaction.
+     * @return Returns a [List] of [StateAndRef] of type [T] from the specified [LedgerTransaction].
+     */
+    fun <T : ContractState> getStateAndRefs(transaction: LedgerTransaction, type: Class<T>): List<StateAndRef<T>> = when (this) {
+        INPUT -> transaction.inRefsOfType(type)
+        OUTPUT -> transaction.outRefsOfType(type)
+        REFERENCE -> transaction.referenceInputRefsOfType(type)
+    }
+
+    /**
+     * Obtains a [List] of [StateAndRef] of type [T] from the specified [LedgerTransaction].
+     *
+     * @param T The underlying [ContractState] type to obtain from the transaction.
+     * @param transaction The [LedgerTransaction] from which to obtain instances of type [T].
+     * @return Returns a [List] of [StateAndRef] of type [T] from the specified [LedgerTransaction].
+     */
+    inline fun <reified T : ContractState> getStateAndRefs(transaction: LedgerTransaction): List<StateAndRef<T>> {
+        return getStateAndRefs(transaction, T::class.java)
+    }
+
+    /**
+     * Obtains a [List] of type [T] from the specified [LedgerTransaction].
+     *
+     * @param T The underlying [ContractState] type to obtain from the transaction.
+     * @param transaction The [LedgerTransaction] from which to obtain instances of type [T].
+     * @param type The [ContractState] type to obtain from the transaction.
+     * @return Returns a [List] of type [T] from the specified [LedgerTransaction].
+     */
+    fun <T : ContractState> getStates(transaction: LedgerTransaction, type: Class<T>): List<T> {
+        return getStateAndRefs(transaction, type).map { it.state.data }
+    }
+
+    /**
+     * Obtains a [List] of type [T] from the specified [LedgerTransaction].
+     *
+     * @param T The underlying [ContractState] type to obtain from the transaction.
+     * @param transaction The [LedgerTransaction] from which to obtain instances of type [T].
+     * @return Returns a [List] of type [T] from the specified [LedgerTransaction].
+     */
+    inline fun <reified T : ContractState> getStates(transaction: LedgerTransaction): List<T> {
+        return getStates(transaction, T::class.java)
+    }
+}