Struct PrivateIndex 

pub struct PrivateIndex { /* private fields */ }

What: A private index file in a directory this value owns. Fields are private, so the directory can be removed only by dropping the value. Why: Every path out of a prediction, failures included, removes the directory.

In TS you’d write (pseudocode):

class PrivateIndex { readonly #directory: string; readonly #index: string; [Symbol.dispose]() {} }

Implementations

impl PrivateIndex

What: impl PrivateIndex { ... } attaches the constructor and the accessor. Why: The directory is created and filled in one step, so no caller sees a half-made copy.

In TS you’d write (pseudocode):

class PrivateIndex { static create(realIndex: string): PrivateIndex; get path(): string }

pub fn create(real_index: &Path) -> Result<PrivateIndex, CandidateError>

What: Create the directory beside real_index and copy the index into it. Why: Beside the real index keeps the copy on the same filesystem and inside the Git directory, where the installed wrapper also put it.

In TS you’d write (pseudocode):

static async create(realIndex: string): Promise<PrivateIndex>;

pub fn path(&self) -> &Path

What: The private index file Git is pointed at. Why: The caller sets GIT_INDEX_FILE to it for every command of the prediction.

In TS you’d write (pseudocode):

get path(): string

Trait Implementations

impl Debug for PrivateIndex

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

Formats the value using the given formatter.

impl Drop for PrivateIndex

What: impl Drop for PrivateIndex runs drop when the value goes out of scope, like a [Symbol.dispose] that the language calls on every exit path. Why: The directory and everything Git wrote into it are removed whether the prediction succeeded or failed.

In TS you’d write (pseudocode):

[Symbol.dispose]() { rmSync(this.#directory, { recursive: true, force: true }); }

fn drop(&mut self)

What: Remove the directory and everything in it. &mut self lends the value for its last use. Why: Called by the language on every exit path, failures included.

In TS you’d write (pseudocode):

[Symbol.dispose](): void

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.