Enum Data

pub enum Data<'a> {
    Missing,
    Buffer {
        buf: &'a [u8],
        is_derived: bool,
    },
    Binary {
        size: u64,
    },
}

Available on crate feature blob only.

The data of a diffable resource, as it could be determined and computed previously.

Variants

Missing

The object is missing, either because it didn’t exist in the working tree or because its id was null.

Buffer

The textual data as processed to be in a diffable state.

Fields

buf: &'a [u8]

The buffer bytes.

is_derived: bool

If true, a binary to text filter was used to obtain the buffer, making it a derived value.

Applications should check for this to avoid treating the buffer content as (original) resource content.

Binary

The size that the binary blob had at the given revision, without having applied filters, as it’s either considered binary or above the big-file threshold.

In this state, the binary file cannot be diffed.

Fields

size: u64

The size of the object prior to performing any filtering or as it was found on disk.

Note that technically, the size isn’t always representative of the same ‘state’ of the content, as once it can be the size of the blob in git, and once it’s the size of file in the worktree.

Implementations

impl<'a> Data<'a>

pub fn as_slice(&self) -> Option<&'a [u8]>

Return ourselves as slice of bytes if this instance stores data.

pub fn is_derived(&self) -> bool

Returns true if the data in this instance is derived.

Trait Implementations

impl<'a> Clone for Data<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Data<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for Data<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> Ord for Data<'a>

fn cmp(&self, other: &Data<'a>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'a> PartialEq for Data<'a>

fn eq(&self, other: &Data<'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> PartialOrd for Data<'a>

fn partial_cmp(&self, other: &Data<'a>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> Copy for Data<'a>

impl<'a> Eq for Data<'a>

impl<'a> StructuralPartialEq for Data<'a>