Struct exonum_configuration::MaybeVote

pub struct MaybeVote(_);

A functional equivalent to Option<VotingDecision> used to store votes in the service schema.

Notes

The None variant of the type is represented by a Vote with all bytes set to zero.

Methods

impl MaybeVote

pub fn none() -> Self

Creates a None variant.

pub fn some(vote: VotingDecision) -> Self

Creates a Some variant.

pub fn is_consent(&self) -> bool

Returns true if it's a Some variant hold Vote.

Methods from Deref<Target = Option<VotingDecision>>

#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"] pub fn is_some(&self) -> bool

Returns true if the option is a Some value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_some(), true);

let x: Option<u32> = None;
assert_eq!(x.is_some(), false);

#[must_use = "if you intended to assert that this doesn\'t have a value, consider `.and_then(|| panic!(\"`Option` had a value when expected `None`\"))` instead"] pub fn is_none(&self) -> bool

Returns true if the option is a None value.

Examples

let x: Option<u32> = Some(2);
assert_eq!(x.is_none(), false);

let x: Option<u32> = None;
assert_eq!(x.is_none(), true);

#[must_use] pub fn contains<U>(&self, x: &U) -> bool where
    U: PartialEq<T>, 

🔬 This is a nightly-only experimental API. (option_result_contains)

Returns true if the option is a Some value containing the given value.

Examples

#![feature(option_result_contains)]

let x: Option<u32> = Some(2);
assert_eq!(x.contains(&2), true);

let x: Option<u32> = Some(3);
assert_eq!(x.contains(&2), false);

let x: Option<u32> = None;
assert_eq!(x.contains(&2), false);

pub fn as_ref(&self) -> Option<&T>

Converts from &Option<T> to Option<&T>.

Examples

Converts an Option<String> into an Option<usize>, preserving the original. The map method takes the self argument by value, consuming the original, so this technique uses as_ref to first take an Option to a reference to the value inside the original.

let text: Option<String> = Some("Hello, world!".to_string());
// First, cast `Option<String>` to `Option<&String>` with `as_ref`,
// then consume *that* with `map`, leaving `text` on the stack.
let text_length: Option<usize> = text.as_ref().map(|s| s.len());
println!("still can print text: {:?}", text);

pub fn as_pin_ref(self: Pin<&'a Option<T>>) -> Option<Pin<&'a T>>

Converts from Pin<&Option<T>> to Option<Pin<&T>>.

pub fn as_pin_mut(self: Pin<&'a mut Option<T>>) -> Option<Pin<&'a mut T>>

Converts from Pin<&mut Option<T>> to Option<Pin<&mut T>>.

pub fn iter(&self) -> Iter<T>

Returns an iterator over the possibly contained value.

Examples

let x = Some(4);
assert_eq!(x.iter().next(), Some(&4));

let x: Option<u32> = None;
assert_eq!(x.iter().next(), None);

pub fn deref(&self) -> Option<&<T as Deref>::Target>

🔬 This is a nightly-only experimental API. (inner_deref)

newly added

Converts from &Option<T> to Option<&T::Target>.

Leaves the original Option in-place, creating a new one with a reference to the original one, additionally coercing the contents via Deref.

Trait Implementations

impl Clone for MaybeVote

fn clone(&self) -> MaybeVote

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<MaybeVote> for Option<VotingDecision>

fn from(vote: MaybeVote) -> Option<VotingDecision>

Performs the conversion.

impl From<VotingDecision> for MaybeVote

fn from(vote: VotingDecision) -> MaybeVote

Performs the conversion.

impl PartialEq<MaybeVote> for MaybeVote

fn eq(&self, other: &MaybeVote) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Debug for MaybeVote

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

Formats the value using the given formatter.

impl Deref for MaybeVote

type Target = Option<VotingDecision>

The resulting type after dereferencing.

fn deref(&self) -> &Option<VotingDecision>

Dereferences the value.

impl BinaryValue for MaybeVote

fn to_bytes(&self) -> Vec<u8>

Serializes the given value to the vector of bytes.

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

Deserializes the value from the given bytes array.

fn into_bytes(self) -> Vec<u8>

Consumes and serializes the given value to the vector of bytes. This method is faster with the wrapped values, thus if you wouldn't use value after serialization use it.

impl ObjectHash for MaybeVote

fn object_hash(&self) -> Hash

Returns a hash of the value.

impl CryptoHash for MaybeVote

fn hash(&self) -> Hash

Returns a hash of the value.