Enum Upward 

pub enum Upward<A, R = ()> {
    Unknown(R),
    Known(A),
}

Type for forward-compatibility with the Concordium Node API.

Wraps enum types which are expected to be extended some future version of the Concordium Node API allowing the current SDK version to handle when new variants are introduced in the API, unknown to this version of the SDK. This is also used for helper methods extracting deeply nested information.

serde implementation (deprecated).

To ensure some level of backwards-compatibility this implements serde::Serialize and serde::Deserialize, but serializing Upward::Unknown will produce a runtime error and deserializing can only produce Upward::Known. The serde implementation should be considered deprecated and might be removed in a future version.

Variants

Unknown(R)

New unknown variant, the structure is not known to the current version of this library. Consider updating the library if support is needed.

For protocols that support decoding unknown data, the residual value is a representation of unknown data (represented by a dynamic data type). This is the case for CBOR e.g., but not possible for protobuf that is not self-descriptive.

Known(A)

Known variant.

Implementations

impl<A, R> Upward<A, R>

pub fn unwrap(self) -> A

Returns the contained Upward::Known value, consuming the self value.

Panics

Panics if the self value equals Upward::Unknown.

pub fn known(self) -> Option<A>

Transforms Upward<T> into a Option<T> where Option::Some represents Upward::Known and Option::None represents Upward::Unknown.

pub fn as_known(&self) -> Option<&A>

Borrow Upward<T> aa Option<&T> where Option::Some represents Upward::Known and Option::None represents Upward::Unknown.

pub fn known_or_err(self) -> Result<A, UnknownDataError>

Require the data to be known, converting it from Upward<A> to Result<A, UnknownDataError>.

This is effectively opt out of forward-compatibility, forcing the library to be up to date with the node version.

pub fn known_or<E>(self, error: E) -> Result<A, E>

Transforms the Upward<T> into a Result<T, E>, mapping Known(v) to Ok(v) and Upward::Unknown to Err(err).

Arguments passed to known_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use known_or_else, which is lazily evaluated.

pub fn known_or_else<E, F>(self, error: F) -> Result<A, E>

where F: FnOnce(R) -> E,

Transforms the Upward<T> into a Result<T, E>, mapping Known(v) to Ok(v) and Upward::Unknown to Err(err()).

pub fn is_known_and(self, f: impl FnOnce(A) -> bool) -> bool

Returns true if the Upward is a Upward::Known and the value inside of it matches a predicate.

pub fn map<U, F>(self, f: F) -> Upward<U, R>

where F: FnOnce(A) -> U,

Maps an Upward<A> to Upward<U> by applying a function to a contained value (if Known) or returns Unknown (if Unknown).

pub fn map_unknown<S, F>(self, f: F) -> Upward<A, S>

where F: FnOnce(R) -> S,

Maps an Upward<A, R> to Upward<A, S> by applying a function to the residual value in Unknown.

pub fn map_or<U, F>(self, default: U, f: F) -> U

where F: FnOnce(A) -> U,

Returns the provided default result (if Upward::Unknown), or applies a function to the contained value (if Upward::Known).

Arguments passed to map_or are eagerly evaluated; if you are passing the result of a function call, it is recommended to use map_or_else, which is lazily evaluated.

pub fn map_or_else<U, D, F>(self, default: D, f: F) -> U

where D: FnOnce() -> U, F: FnOnce(A) -> U,

Computes a default function result (if Upward::Unknown), or applies a different function to the contained value (if Upward::Known).

pub const fn as_ref_with_residual(&self) -> Upward<&A, &R>

Converts from &Upward<A, R> to Upward<&A, &R>.

pub fn and_then<U, F>(self, f: F) -> Upward<U, R>

where F: FnOnce(A) -> Upward<U, R>,

Returns Upward::Unknown if the option is Upward::Unknown, otherwise calls f with the wrapped value and returns the result.

impl<A> Upward<A>

pub const fn as_ref(&self) -> Upward<&A>

Converts from &Upward<A> to Upward<&A>.

impl<A, R, E> Upward<Result<A, E>, R>

pub fn transpose(self) -> Result<Upward<A, R>, E>

Transposes an Upward of a Result into a Result of an Upward.

Trait Implementations

impl<T> CborDeserialize for Upward<T, Value>

where T: CborDeserialize,

fn deserialize<C>( decoder: C, ) -> Result<Upward<T, Value>, CborSerializationError>

where C: CborDecoder, Upward<T, Value>: Sized,

Deserialize value from the given decoder

fn deserialize_maybe_known<C>( decoder: C, ) -> Result<CborMaybeKnown<Self>, CborSerializationError>

where C: CborDecoder, Self: Sized,

fn null() -> Option<Self>

where Self: Sized,

Produce value corresponding to null if possible for this type

impl<T> CborSerialize for Upward<T, Value>

where T: CborSerialize,

fn serialize<C>(&self, encoder: C) -> Result<(), CborSerializationError>

where C: CborEncoder,

Serialize value to CBOR

fn is_null(&self) -> bool

Whether the value corresponds to null

impl<A, R> Clone for Upward<A, R>

where A: Clone, R: Clone,

fn clone(&self) -> Upward<A, R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A, R> Debug for Upward<A, R>

where A: Debug, R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, A, R> Deserialize<'de> for Upward<A, R>

where A: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Upward<A, R>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&AccountInfo> for Upward<AccountAccessStructure>

fn from(value: &AccountInfo) -> Self

Converts to this type from the input type.

impl<A> From<Option<A>> for Upward<A>

fn from(value: Option<A>) -> Upward<A>

Converts to this type from the input type.

impl From<Upward<RejectReason>> for Cis2DryRunError

fn from(err: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for Cis2QueryError

fn from(err: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for Cis3PermitDryRunError

fn from(err: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for Cis3SupportsPermitError

fn from(err: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for Cis4QueryError

fn from(value: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for DryRunModuleDeployError

fn from(value: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for DryRunNewInstanceError

fn from(value: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl From<Upward<RejectReason>> for ViewError

fn from(value: Upward<RejectReason>) -> Self

Converts to this type from the input type.

impl<A> FromIterator<Upward<A>> for Upward<Vec<A>>

fn from_iter<T>(iter: T) -> Upward<Vec<A>>

where T: IntoIterator<Item = Upward<A>>,

Creates a value from an iterator.

impl<A, R> Hash for Upward<A, R>

where A: Hash, R: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A, R> Ord for Upward<A, R>

where A: Ord, R: Ord,

fn cmp(&self, other: &Upward<A, R>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<A, R> PartialEq for Upward<A, R>

where A: PartialEq, R: PartialEq,

fn eq(&self, other: &Upward<A, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, R> PartialOrd for Upward<A, R>

where A: PartialOrd, R: PartialOrd,

fn partial_cmp(&self, other: &Upward<A, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<A, R> Serialize for Upward<A, R>

where A: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<AccountCredential> for Upward<AccountCredentialWithoutProofs<ArCurve, AttributeKind>>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(message: AccountCredential) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<AccountVerifyKey> for Upward<VerifyKey>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(value: AccountVerifyKey) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BlockItem> for Upward<BlockItem<EncodedPayload>>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(value: BlockItem) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BlockSpecialEvent> for Upward<SpecialTransactionOutcome>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(message: BlockSpecialEvent) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<CredentialPublicKeys> for Upward<CredentialPublicKeys>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(value: CredentialPublicKeys) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<CredentialValues> for Upward<AccountCredentialWithoutProofs<ArCurve, AttributeKind>>

type Error = Status

The type returned in the event of a conversion error.

fn try_from(cred: CredentialValues) -> Result<Self, Self::Error>

Performs the conversion.

impl<A, R> Copy for Upward<A, R>

where A: Copy, R: Copy,

impl<A, R> Eq for Upward<A, R>

where A: Eq, R: Eq,

impl<A, R> StructuralPartialEq for Upward<A, R>