Enum Maybe 

pub enum Maybe<T> {
    Some(T),
    None,
}

A type that represents an entrypoint arg that may or may not be present.

Variants

Some(T)

A value is present.

None

No value is present.

Implementations

impl<T> Maybe<T>

pub fn is_some(&self) -> bool

Returns true if the value is present.

pub fn is_none(&self) -> bool

Returns true if the value is not present.

pub fn unwrap(self, env: &ContractEnv) -> T

Unwraps the value. If the value is not present, the contract reverts with an ExecutionError::UnwrapError.

pub fn unwrap_or(self, default: T) -> T

Unwraps the value or returns the default value.

impl<T: Default> Maybe<T>

pub fn unwrap_or_default(self) -> T

Unwraps the value or returns the default value.

Trait Implementations

impl<T: Clone> Clone for Maybe<T>

fn clone(&self) -> Maybe<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Maybe<T>

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

Formats the value using the given formatter.

impl<T> Default for Maybe<T>

fn default() -> Maybe<T>

Returns the “default value” for a type.

impl<T: CLTyped + ToBytes> EntrypointArgument for Maybe<T>

fn is_required() -> bool

Returns true if the argument is required.

fn cl_type() -> CLType

Returns the CLType of the argument.

fn insert_runtime_arg(self, name: &str, args: &mut RuntimeArgs)

Inserts the argument into the runtime args.

fn unwrap(value: Option<Self>, _env: &ContractEnv) -> Self

Unwraps the argument from an Option.

impl<T: FromBytes> FromBytes for Maybe<T>

fn from_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error>

Deserializes the slice into Self.

fn from_vec(bytes: Vec<u8>) -> Result<(Self, Vec<u8>), Error>

Deserializes the Vec<u8> into Self.

impl<T: ToBytes> ToBytes for Maybe<T>

fn to_bytes(&self) -> Result<Vec<u8>, Error>

Serializes &self to a Vec<u8>.

fn serialized_length(&self) -> usize

Returns the length of the Vec<u8> which would be returned from a successful call to to_bytes() or into_bytes(). The data is not actually serialized, so this call is relatively cheap.

fn into_bytes(self) -> Result<Vec<u8>, Error>

where Self: Sized,

Consumes self and serializes to a Vec<u8>.

fn write_bytes(&self, writer: &mut Vec<u8>) -> Result<(), Error>

Writes &self into a mutable writer.