Struct tendermint_testgen::commit::Commit

pub struct Commit {
    pub header: Option<Header>,
    pub votes: Option<Vec<Vote>>,
    pub round: Option<u32>,
}

Fields

header: Option<Header>

votes: Option<Vec<Vote>>

round: Option<u32>

Implementations

impl Commit

pub fn new(header: Header, round: u32) -> Self

Make a new commit using default votes produced from the header.

pub fn new_with_votes(header: Header, round: u32, votes: Vec<Vote>) -> Self

Make a new commit using explicit votes.

pub fn header(self, header: Header) -> Self

pub fn votes(self, votes: Vec<Vote>) -> Self

pub fn round(self, round: u32) -> Self

pub fn generate_default_votes(self) -> Self

Generate commit votes from all validators in the header. This function will panic if the header is not present

pub fn vote_of_validator(&mut self, id: &str) -> &mut Vote

Get a mutable reference to the vote of the given validator. This function will panic if the votes or the validator vote is not present

pub fn vote_at_index(&mut self, index: usize) -> &mut Vote

Get a mutable reference to the vote at the given index This function will panic if the votes or the vote at index is not present

Trait Implementations

impl Clone for Commit

fn clone(&self) -> Commit

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Commit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Commit

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromStr for Commit

type Err = SimpleError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Generator<Commit> for Commit

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

Merge this companion with the another, default one. The options present in this object will override those in the default one.

fn generate(&self) -> Result<Commit, SimpleError>

Generate the complex object from this companion object.

fn encode(&self) -> Result<String, SimpleError>

Generate and serialize the complex object

impl Options for Commit

fn parse<__S: AsRef<str>>(_parser: &mut Parser<'_, __S>) -> Result<Self, Error>

Parses arguments until the given parser is exhausted or until an error is encountered.

fn command(&self) -> Option<&dyn Options>

Returns the subcommand instance, if present.

fn command_name(&self) -> Option<&'static str>

Returns the name of a parsed command, if present.

fn help_requested(&self) -> bool

Returns whether the user supplied a “help” option to request usage information about the program or any contained subcommands.

fn parse_command<__S: AsRef<str>>( name: &str, _parser: &mut Parser<'_, __S> ) -> Result<Self, Error>

Parses options for the named command.

fn usage() -> &'static str

Returns a string showing usage and help for each supported option.

fn self_usage(&self) -> &'static str

Returns a string showing usage and help for this options instance.

fn command_list() -> Option<&'static str>

Returns a string listing available commands and help text.

fn command_usage(_name: &str) -> Option<&'static str>

Returns a usage string for the named command.

fn self_command_list(&self) -> Option<&'static str>

Returns a listing of available commands and help text.

fn parse_args<S>(args: &[S], style: ParsingStyle) -> Result<Self, Error>

where S: AsRef<str>, Self: Sized,

Parses arguments received from the command line.

fn parse_args_or_exit(style: ParsingStyle) -> Self

where Self: Sized,

Parses arguments from the environment.

fn parse_args_default_or_exit() -> Self

where Self: Sized,

Parses arguments from the environment, using the default parsing style.

fn parse_args_default<S>(args: &[S]) -> Result<Self, Error>

where S: AsRef<str>, Self: Sized,

Parses arguments received from the command line, using the default parsing style.

impl Serialize for Commit

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.