final case class GenTransaction[Nid, +Cid](nodes: Map[Nid, GenNode[Nid, Cid]], roots: ImmArray[Nid]) extends HasTxNodes[Nid, Cid] with CidContainer[GenTransaction[Nid, Cid]] with Product with Serializable
General transaction type
Abstracts over NodeId type and ContractId type ContractId restricts the occurrence of contractIds
- nodes
The nodes of this transaction.
- roots
References to the root nodes of the transaction. Users of this class may assume that all instances are well-formed, i.e.,
isWellFormed.isEmpty. For performance reasons, users are not required to callisWellFormed. Therefore, it is forbidden to create ill-formed instances, i.e., instances with!isWellFormed.isEmpty.
- Alphabetic
- By Inheritance
- GenTransaction
- Serializable
- Product
- Equals
- CidContainer
- HasTxNodes
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new GenTransaction(nodes: Map[Nid, GenNode[Nid, Cid]], roots: ImmArray[Nid])
- nodes
The nodes of this transaction.
- roots
References to the root nodes of the transaction. Users of this class may assume that all instances are well-formed, i.e.,
isWellFormed.isEmpty. For performance reasons, users are not required to callisWellFormed. Therefore, it is forbidden to create ill-formed instances, i.e., instances with!isWellFormed.isEmpty.
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- final def assertNoCid[B](message: (ContractId) => String)(implicit checker: NoCidChecker[GenTransaction[Nid, Cid], B]): B
- Definition Classes
- CidContainer
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def compareForest[Nid2, Cid2](other: GenTransaction[Nid2, Cid2])(compare: (GenNode[Nothing, Cid], GenNode[Nothing, Cid2]) => Boolean): Boolean
Compares two Transactions up to renaming of Nids.
Compares two Transactions up to renaming of Nids. with the specified comparision of nodes Nid is irrelevant to the content of the transaction.
- final def consumedContracts[Cid2 >: Cid]: Set[Cid2]
Returns the IDs of all the consumed contracts.
Returns the IDs of all the consumed contracts. This includes transient contracts but it does not include contracts consumed in rollback nodes.
- Definition Classes
- HasTxNodes
- final def contractKeyInputs(implicit evidence: <:<[HasTxNodes[Nid, Cid], HasTxNodes[_, ContractId]]): Either[KeyInputError, Map[GlobalKey, KeyInput]]
Return the expected contract key inputs (i.e.
Return the expected contract key inputs (i.e. the state before the transaction) for this transaction or an error if the transaction contains a duplicate key error or has an inconsistent mapping for a key. For KeyCreate and NegativeKeyLookup (both corresponding to the key not being active) the first required input in execution order wins. So if a create comes first the input will be set to KeyCreate, if a negative lookup by key comes first the input will be set to NegativeKeyLookup.
Because we do not preserve byKey flags across transaction serialization this method will consider all operations with keys for conflicts rather than just by-key operations.
- Definition Classes
- HasTxNodes
- Annotations
- @throws("If a contract key contains a contract id")
- final def contractKeys(implicit evidence: <:<[HasTxNodes[Nid, Cid], HasTxNodes[_, ContractId]]): Set[GlobalKey]
Return all the contract keys referenced by this transaction.
Return all the contract keys referenced by this transaction. This includes the keys created, exercised, fetched, or looked up, even those that refer transient contracts or that appear under a rollback node.
- Definition Classes
- HasTxNodes
- final def ensureNoCid[B](implicit checker: NoCidChecker[GenTransaction[Nid, Cid], B]): Either[ContractId, B]
- Definition Classes
- CidContainer
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equalForest[Cid2 >: Cid](other: GenTransaction[_, Cid2]): Boolean
Compares two Transactions up to renaming of Nids.
Compares two Transactions up to renaming of Nids. You most likely want to use this rather than ==, since the Nid is irrelevant to the content of the transaction.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def fold[A](z: A)(f: (A, (Nid, GenNode[Nid, Cid])) => A): A
Traverses the transaction tree in pre-order traversal (i.e.
Traverses the transaction tree in pre-order traversal (i.e. exercise nodes are traversed before their children)
Takes constant stack space. Crashes if the transaction is not well formed (see
isWellFormed)- Definition Classes
- HasTxNodes
- final def foldInExecutionOrder[A](z: A)(exerciseBegin: (A, Nid, NodeExercises[Nid, Cid]) => (A, Boolean), rollbackBegin: (A, Nid, NodeRollback[Nid]) => (A, Boolean), leaf: (A, Nid, LeafOnlyActionNode[Cid]) => A, exerciseEnd: (A, Nid, NodeExercises[Nid, Cid]) => A, rollbackEnd: (A, Nid, NodeRollback[Nid]) => A): A
- Definition Classes
- HasTxNodes
- def foldValues[Z](z: Z)(f: (Z, Value[Cid]) => Z): Z
Visit every
Val. - final def foldWithPathState[A, B](globalState0: A, pathState0: B)(op: (A, B, Nid, GenNode[Nid, Cid]) => (A, B)): A
A fold over the transaction that maintains global and path-specific state.
A fold over the transaction that maintains global and path-specific state. Takes constant stack space. Returns the global state.
Used to for example compute the roots of per-party projections from the transaction.
- Definition Classes
- HasTxNodes
- final def foreach(f: (Nid, GenNode[Nid, Cid]) => Unit): Unit
This function traverses the transaction tree in pre-order traversal (i.e.
This function traverses the transaction tree in pre-order traversal (i.e. exercise node are traversed before their children).
Takes constant stack space. Crashes if the transaction is not well formed (see
isWellFormed)- Definition Classes
- HasTxNodes
- final def foreachInExecutionOrder(exerciseBegin: (Nid, NodeExercises[Nid, Cid]) => Boolean, rollbackBegin: (Nid, NodeRollback[Nid]) => Boolean, leaf: (Nid, LeafOnlyActionNode[Cid]) => Unit, exerciseEnd: (Nid, NodeExercises[Nid, Cid]) => Unit, rollbackEnd: (Nid, NodeRollback[Nid]) => Unit): Unit
- Definition Classes
- HasTxNodes
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def guessSubmitter: Either[String, Party]
- Definition Classes
- HasTxNodes
- final def inactiveContracts[Cid2 >: Cid]: Set[Cid2]
Local and global contracts that are inactive at the end of the transaction.
Local and global contracts that are inactive at the end of the transaction. This includes both contracts that have been arachived and local contracts whose create has been rolled back.
- Definition Classes
- HasTxNodes
- lazy val informees: Set[Party]
The union of the informees of a all the action nodes.
The union of the informees of a all the action nodes.
- Definition Classes
- HasTxNodes
- final def inputContracts[Cid2 >: Cid]: Set[Cid2]
Returns the IDs of all input contracts that are used by this transaction.
Returns the IDs of all input contracts that are used by this transaction.
- Definition Classes
- HasTxNodes
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isWellFormed: Set[NotWellFormedError[Nid]]
This function checks the following properties:
This function checks the following properties:
* No dangling references -- all node ids mentioned in the forest are in the nodes map; * No orphaned references -- all keys of the node map are mentioned in the forest; * No aliasing -- every node id in the node map is mentioned exactly once, in the roots list or as a child of another node.
- final def localContracts[Cid2 >: Cid]: Map[Cid2, (Nid, NodeCreate[Cid2])]
- Definition Classes
- HasTxNodes
- def mapNodeId[Nid2](f: (Nid) => Nid2): GenTransaction[Nid2, Cid]
Note: the provided function must be injective, otherwise the transaction will be corrupted.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val nodes: Map[Nid, GenNode[Nid, Cid]]
- Definition Classes
- GenTransaction → HasTxNodes
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- final def reachableNodeIds: Set[Nid]
- Definition Classes
- HasTxNodes
- def rootNodes: ImmArray[GenActionNode[Nid, Cid]]
- Definition Classes
- HasTxNodes
- Annotations
- @throws(scala.this.throws.<init>$default$1[IllegalArgumentException])
- val roots: ImmArray[Nid]
- Definition Classes
- GenTransaction → HasTxNodes
- def self: GenTransaction.this.type
- Attributes
- protected
- Definition Classes
- GenTransaction → CidContainer
- def serializable(f: (Value[Cid]) => ImmArray[String]): ImmArray[String]
checks that all the values contained are serializable
- final def suffixCid[B](f: (Hash) => Bytes)(implicit suffixer: CidSuffixer[GenTransaction[Nid, Cid], B]): Either[String, B]
- Definition Classes
- CidContainer
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- final def updatedContractKeys(implicit ev: <:<[HasTxNodes[Nid, Cid], HasTxNodes[_, ContractId]]): Map[GlobalKey, Option[ContractId]]
The contract keys created or updated as part of the transaction.
The contract keys created or updated as part of the transaction. This includes updates to transient contracts (by mapping them to None) but it does not include any updates under rollback nodes.
- Definition Classes
- HasTxNodes
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()