Packages

case class State extends Product with Serializable

Linear Supertypes
Serializable, Product, Equals, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. State
  2. Serializable
  3. Product
  4. Equals
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. val activeState: ActiveLedgerState[Nid]
  5. def advance(resolver: KeyResolver, substate: State): Either[KeyInputError, State]

    Let this state be the result of iterating over a transaction tx until just before a node n.

    Let this state be the result of iterating over a transaction tx until just before a node n. Let substate be the state obtained after fully iterating over the subtree rooted at n starting from State.empty. Then, advance(resolver, substate) equals the state resulting from iterating over tx until processing all descendants of n.

    The call to advance(resolver, substate) fails if and only if the iteration over the subtree rooted at n starting from this fails, but the error may be different.

    resolver

    In mode ContractKeyUniquenessMode.Strict, this parameter has no effect. In mode ContractKeyUniquenessMode.Off, resolver must be the resolver used while iterating over tx until just before n. While iterating over the subtree rooted at n, projectKeyResolver(resolver) must be used as resolver.

    substate

    The state obtained after fully iterating over the subtree n starting from State.empty. Consumed contracts (activeState.consumedBy) in this and substate must be disjoint.

    See also

    com.daml.lf.transaction.HasTxNodes.contractKeyInputs for an iteration in mode com.daml.lf.transaction.ContractKeyUniquenessMode.Strict and

    ContractStateMachineSpec.visitSubtree for iteration in all modes

  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def beginRollback(): State

    To be called when interpretation enters a try block or iteration enters a Rollback node Must be matched by endRollback or dropRollback.

  8. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  9. def consumedByOrInactive(cid: ContractId): Option[Either[Nid, Unit]]

    The return value indicates if the given contract is either consumed, inactive, or otherwise - Some(Left(nid)) -- consumed by a specified node-id - Some(Right(())) -- inactive, because the (local) contract creation has been rolled-back - None -- neither consumed nor inactive

  10. def dropRollback(): State

    To be called if interpretation notices that a try block did not lead to a Rollback node Must be matched by a beginRollback.

  11. def endRollback(): State

    To be called when interpretation does insert a Rollback node or iteration leaves a Rollback node.

    To be called when interpretation does insert a Rollback node or iteration leaves a Rollback node. Must be matched by a beginRollback.

  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  14. val globalKeyInputs: Map[GlobalKey, KeyInput]
  15. def handleCreate(node: Create): Either[KeyInputError, State]

    Visit a create node

  16. def handleExercise(nid: Nid, exe: Exercise): Either[KeyInputError, State]
  17. def handleFetch(node: Fetch): Either[KeyInputError, State]
  18. def handleLookup(lookup: LookupByKey): Either[KeyInputError, State]

    Must be used to handle lookups iff in com.daml.lf.transaction.ContractKeyUniquenessMode.Strict mode

  19. def handleLookupWith(lookup: LookupByKey, keyInput: Option[ContractId]): Either[KeyInputError, State]

    Must be used to handle lookups iff in com.daml.lf.transaction.ContractKeyUniquenessMode.Off mode The second argument takes the contract key resolution to be given to the Daml interpreter instead of com.daml.lf.transaction.Node.LookupByKey.result.

    Must be used to handle lookups iff in com.daml.lf.transaction.ContractKeyUniquenessMode.Off mode The second argument takes the contract key resolution to be given to the Daml interpreter instead of com.daml.lf.transaction.Node.LookupByKey.result. This is because the iteration might currently be within a rollback scope that has already archived a contract with the key without a by-key operation (and for this reason the archival is not tracked in ContractStateMachine.ActiveLedgerState.keys), i.e., the lookup resolves to scala.None$ but the correct key input is scala.Some$ for some contract ID and this may matter after the rollback scope is left. Daml Engine will ask the ledger in that case to resolve the lookup and then perform an activeness check against the result potentially turning it into a negative lookup.

  20. def handleNode(id: Nid, node: Action, keyInput: => Option[ContractId]): Either[KeyInputError, State]

    Utility method that takes a node and computes the corresponding next state.

    Utility method that takes a node and computes the corresponding next state. The method does not handle any children of node; it is up to the caller to do that.

    keyInput

    will only be used in mode ContractKeyUniquenessMode.Off and if the node is a lookupByKey

  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. val locallyCreated: Set[ContractId]
  23. def lookupActiveGlobalKeyInput(key: GlobalKey): Option[KeyMapping]
  24. def lookupActiveKey(key: GlobalKey): Option[KeyMapping]

    Lookup the given key k.

    Lookup the given key k. Returns - Some(KeyActive(cid)) if k maps to cid and cid is active. - Some(KeyInactive) if there is no active contract with the given key. - None if we know no mapping for that key.

  25. def mode: ContractKeyUniquenessMode
  26. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  27. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  28. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  29. def productElementNames: Iterator[String]
    Definition Classes
    Product
  30. def projectKeyResolver(resolver: KeyResolver): KeyResolver

    See also

    advance

  31. val rollbackStack: List[ActiveLedgerState[Nid]]
  32. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  33. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  34. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  35. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated
    Deprecated

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped