Struct RecordState

pub struct RecordState<'a> {
    pub is_read_only: bool,
    pub commits: Vec<Commit>,
    pub files: Vec<File<'a>>,
}

The state used to render the changes. This is passed into crate::Recorder::new and then updated and returned with crate::Recorder::run.

Fields

is_read_only: bool

Render the UI as read-only, such that the checkbox states cannot be changed by the user.

commits: Vec<Commit>

The commits containing the selected changes. Each changed section be assigned to exactly one commit.

If there are fewer than two commits in this list, then it is padded to two commits using Commit::default before being returned.

It’s important to note that the Commits do not literally contain the selected changes. They are stored out-of-band in the files field. It would be possible to store the changes in the Commits, but we would no longer get the invariant that each change belongs to a single commit for free. (That being said, we now have to uphold the invariant that the changes are all assigned to valid commits.) It would also be somewhat more tedious to write the code that removes the change from one Commit and adds it to the correct relative position (with respect to all of the other changes) in another Commit.

files: Vec<File<'a>>

The state of each file. This is rendered in order, so you may want to sort this list by path before providing it.

Trait Implementations

impl<'a> Clone for RecordState<'a>

fn clone(&self) -> RecordState<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RecordState<'a>

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

Formats the value using the given formatter.

impl<'a> Default for RecordState<'a>

fn default() -> RecordState<'a>

Returns the “default value” for a type.

impl<'de, 'a> Deserialize<'de> for RecordState<'a>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> PartialEq for RecordState<'a>

fn eq(&self, other: &RecordState<'a>) -> 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> Serialize for RecordState<'a>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for RecordState<'a>

impl<'a> StructuralPartialEq for RecordState<'a>