LinearPointer
Keywords: net.corda.core.contracts.LinearPointer class
Date: 2023-09-18

net.corda.core.contracts

## Class LinearPointer<T extends LinearState>

- net.corda.core.contracts.StatePointer<T>
- - net.corda.core.contracts.LinearPointer<T>

-     public class LinearPointer<T extends LinearState>
      extends StatePointer<T>

  `class LinearPointer` allows a `interface ContractState` to "point" to another `interface LinearState` creating a "many-to-one" relationship between all the states containing the pointer to a particular `interface LinearState` and the `interface LinearState` being pointed to. Using the `class LinearPointer` is useful when one state depends on the data contained within another state that evolves independently. When using `class LinearPointer` it is worth noting:

  - The node performing the resolution may not have seen any `interface LinearState`s with the specified linearId, as such the vault query in `resolve` will return null and `resolve` will throw an exception

  - The node performing the resolution may not have the latest version of the `interface LinearState` and therefore will return an older version of the `interface LinearState`. As the pointed-to state will be added as a reference state to the transaction then the transaction with such a reference state cannot be committed to the ledger until the most up-to-date version of the `interface LinearState` is available. See reference states documentation on docs.corda.net for more info.

  See Also:
    `class LinearPointer`, `interface ContractState`, `interface LinearState`, `interface LinearState`, `interface LinearState`, `class LinearPointer`, `class LinearPointer`, `interface LinearState`, linearId, `resolve`, `resolve`, `interface LinearState`, `interface LinearState`, `interface LinearState`

- - ### Constructor Detail

    - #### LinearPointer

          public LinearPointer(@NotNull
                               UniqueIdentifier pointer,
                               @NotNull
                               java.lang.Class<T> type,
                               boolean isResolved)

      `class LinearPointer` allows a `interface ContractState` to "point" to another `interface LinearState` creating a "many-to-one" relationship between all the states containing the pointer to a particular `interface LinearState` and the `interface LinearState` being pointed to. Using the `class LinearPointer` is useful when one state depends on the data contained within another state that evolves independently. When using `class LinearPointer` it is worth noting:

      - The node performing the resolution may not have seen any `interface LinearState`s with the specified linearId, as such the vault query in `resolve` will return null and `resolve` will throw an exception

      - The node performing the resolution may not have the latest version of the `interface LinearState` and therefore will return an older version of the `interface LinearState`. As the pointed-to state will be added as a reference state to the transaction then the transaction with such a reference state cannot be committed to the ledger until the most up-to-date version of the `interface LinearState` is available. See reference states documentation on docs.corda.net for more info.

      Parameters:
        `pointer` - An identifier for the `interface ContractState` that this `class StatePointer` points to.
        `type` - Type of the state which is being pointed to.
        `isResolved` - Determines whether the state pointer should be resolved to a reference input when used in a transaction.
      See Also:
        `class LinearPointer`, `interface ContractState`, `interface LinearState`, `interface LinearState`, `interface LinearState`, `class LinearPointer`, `class LinearPointer`, `interface LinearState`, linearId, `resolve`, `resolve`, `interface LinearState`, `interface LinearState`, `interface LinearState`

    - #### LinearPointer

          public LinearPointer(@NotNull
                               UniqueIdentifier pointer,
                               @NotNull
                               java.lang.Class<T> type)

      Allows this class to be evolved through backwards compatibility with version 1 of this class.

      Parameters:
        `pointer` - The unique identifier that this points to.
        `type` - The underlying `interface LinearState` type that this points to.

  - ### Method Detail

    - #### resolve

          @NotNull
          public StateAndRef<T> resolve(@NotNull
                                                 ServiceHub services)

      Resolves a `class LinearPointer` using the `class UniqueIdentifier` contained in the pointer property. Returns a `class StateAndRef` containing the latest version of the `interface LinearState` that the node calling `resolve` is aware of.

      Parameters:
        `services` - a `interface ServiceHub` implementation is required to perform a vault query.
      See Also:
        `class LinearPointer`, `class UniqueIdentifier`, `class StateAndRef`, `interface LinearState`, `resolve`

    - #### resolve

          @NotNull
          public StateAndRef<T> resolve(@NotNull
                                                 LedgerTransaction ltx)

      Resolves a `class StatePointer` to a `class StateAndRef` from inside a `class LedgerTransaction`. The intuition here is that all of the pointed-to states will be included in the transaction as reference states.

      Parameters:
        `ltx` - the `class LedgerTransaction` containing the `pointer` and pointed-to states.
      See Also:
        `class StatePointer`, `class StateAndRef`, `class LedgerTransaction`

    - #### equals

          public boolean equals(@Nullable
                                java.lang.Object other)

    - #### hashCode

          public int hashCode()

    - #### getPointer

          @NotNull
          public UniqueIdentifier getPointer()

      An identifier for the

      `interface ContractState` that this `class StatePointer` points to.

      See Also:
        `interface ContractState`, `class StatePointer`

    - #### getType

          @NotNull
          public java.lang.Class<T> getType()

      Type of the state which is being pointed to.

    - #### isResolved

          public boolean isResolved()

      Determines whether the state pointer should be resolved to a reference input when used in a transaction.