Struct EventPath 

pub struct EventPath { /* private fields */ }

What: One path as events report it. The fields are private, so the only ways to build one are the two constructors, and exact is present exactly when the bytes were not UTF-8. #[derive(...)] generates cloning, debug printing and ==. Why: A reader must be able to rely on “no pathBytes means path is the exact name”.

In TS you’d write (pseudocode):

type EventPath = { readonly text: string; readonly exact?: Uint8Array };

Implementations

impl EventPath

What: impl EventPath { ... } attaches the constructors and the two reads. Why: The invariant between the two fields is kept in one place.

In TS you’d write (pseudocode):

class EventPath { static fromGitBytes(bytes) {} static display(text) {} }

pub fn from_git_bytes(bytes: &[u8]) -> EventPath

What: The event form of a pathname exactly as Git printed it. &[u8] borrows the bytes; String::from_utf8_lossy replaces each invalid sequence by U+FFFD. Why: A UTF-8 name is its own exact form and gets no extra field; any other name keeps its bytes, because different names can share one replaced text.

In TS you’d write (pseudocode):

static fromGitBytes(bytes: Uint8Array): EventPath;

pub fn display(text: &str) -> EventPath

What: A path whose event form is text only. &str borrows the text. Why: A constant name, or the scanner’s masked display of a name, is already text; the masked display must never carry the bytes it masks.

In TS you’d write (pseudocode):

static display(text: string): EventPath;

pub fn text(&self) -> &str

What: The readable text of the path. &str borrows it from the record. Why: Every event prints it as path, whatever else it prints.

In TS you’d write (pseudocode):

get text(): string;

pub fn exact(&self) -> Option<&[u8]>

What: The exact bytes, only when they are not UTF-8. Option<&[u8]> lends them or says there are none. Why: Rendering adds pathBytes exactly when this is present.

In TS you’d write (pseudocode):

get exact(): Uint8Array | undefined;

pub fn bytes(&self) -> &[u8]

What: The bytes of the name: the exact ones when kept, else the text’s UTF-8 bytes. Why: A list of paths that holds one name that is not UTF-8 lists the bytes of every name, so its entries line up with the readable list one for one.

In TS you’d write (pseudocode):

get bytes(): Uint8Array { return this.exact ?? new TextEncoder().encode(this.text); }

Trait Implementations

impl Clone for EventPath

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventPath

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

Formats the value using the given formatter.

impl Eq for EventPath

impl PartialEq for EventPath

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for EventPath