Enum PendingFixupsResult 

pub enum PendingFixupsResult {
    None,
    Some(PendingFixupsStats),
    Unknown {
        reason: String,
    },
}

Result of attempting to determine pending fixups state

This tri-state result allows callers to distinguish between:

• No fixups needed (None)
• Fixups found (Some(stats))
• Unable to determine (Unknown) - e.g., corrupted review artifact

Variants

None

No fixups are pending (review completed, no markers, or review not done yet)

Some(PendingFixupsStats)

Fixups are pending with the given statistics

Unknown

Unable to determine fixup state (e.g., markers present but parse failed)

Fields

reason: String

Reason why fixups state couldn’t be determined

Implementations

impl PendingFixupsResult

pub fn is_none(&self) -> bool

Check if there are definitely no pending fixups

pub fn is_some(&self) -> bool

Check if fixups are definitely pending

pub fn is_unknown(&self) -> bool

Check if fixup state is unknown/indeterminate

pub fn stats(&self) -> Option<&PendingFixupsStats>

Get the stats if fixups are pending

pub fn targets_or_zero(&self) -> u32

Get the target count, or 0 if none/unknown

Note: Use this only for display purposes. For gate checks, use is_unknown() to detect indeterminate states.

pub fn into_stats(self) -> PendingFixupsStats

Convert to legacy PendingFixupsStats (for backward compatibility)

Returns default stats (zeros) for None and Unknown states.

Trait Implementations

impl Clone for PendingFixupsResult

fn clone(&self) -> PendingFixupsResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PendingFixupsResult

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PendingFixupsResult

fn deserialize<__D>( __deserializer: __D, ) -> Result<PendingFixupsResult, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for PendingFixupsResult

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.