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 LinearStates 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 LinearStates 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.