Struct git_ref::file::Store

pub struct Store {
    pub base: PathBuf,
    pub write_reflog: WriteReflog,
}

A store for reference which uses plain files.

Each ref is represented as a single file on disk in a folder structure that follows the relative path used to identify references.

Fields

base: PathBuf

The location at which loose references can be found as per conventions of a typical git repository.

Typical base paths are .git repository folders.

write_reflog: WriteReflog

The way to handle reflog edits

Implementations

impl Store

pub fn reflog_exists<'a, Name, E>(&self, name: Name) -> Result<bool, E> where
    Name: TryInto<FullName<'a>, Error = E>,
    Error: From<E>, 

Returns true if a reflog exists for the given reference name.

Please note that this method shouldn’t be used to check if a log exists before trying to read it, but instead is meant to be the fastest possible way to determine if a log exists or not. If the caller needs to know if it’s readable, try to read the log instead with a reverse or forward iterator.

pub fn reflog_iter_rev<'a, 'b, Name, E>(
    &self,
    name: Name,
    buf: &'b mut [u8]
) -> Result<Option<Reverse<'b, File>>, Error> where
    Name: TryInto<FullName<'a>, Error = E>,
    Error: From<E>, 

Return a reflog reverse iterator for the given fully qualified name, reading chunks from the back into the fixed buffer buf.

The iterator will traverse log entries from most recent to oldest, reading the underlying file in chunks from the back. Return Ok(None) if no reflog exists.

pub fn reflog_iter<'a, 'b, Name, E>(
    &self,
    name: Name,
    buf: &'b mut Vec<u8>
) -> Result<Option<impl Iterator<Item = Result<Line<'b>, Error>>>, Error> where
    Name: TryInto<FullName<'a>, Error = E>,
    Error: From<E>, 

Return a reflog forward iterator for the given fully qualified name and write its file contents into buf.

The iterator will traverse log entries from oldest to newest. Return Ok(None) if no reflog exists.

impl Store

pub fn loose_iter(&self) -> Result<Loose>

Return an iterator over all loose references, notably not including any packed ones, in file system order. Each of the references may fail to parse and the iterator will not stop if parsing fails, allowing the caller to see all files that look like references whether valid or not.

Reference files that do not constitute valid names will be silently ignored.

See Store::packed() for interacting with packed references.

pub fn loose_iter_prefixed(&self, prefix: impl AsRef<Path>) -> Result<Loose>

Return an iterator over all loose references that start with the given prefix.

Otherwise it’s similar to loose_iter().

impl Store

pub fn at(git_dir: impl Into<PathBuf>, write_reflog: WriteReflog) -> Self

Create a new instance at the given git_dir, which commonly is a standard git repository with a refs/ subdirectory.

impl Store

pub fn iter<'p, 's>(
    &'s self,
    packed: Option<&'p Buffer>
) -> Result<LooseThenPacked<'p, 's>>

Return an iterator over all references, loose or packed, sorted by their name.

Note that the caller is responsible for the freshness of the packed references buffer. If a reference cannot be parsed or read, the error will be visible to the caller and the iteration continues.

Errors are returned similarly to what would happen when loose and packed refs where iterated by themeselves.

pub fn iter_prefixed<'p, 's>(
    &'s self,
    packed: Option<&'p Buffer>,
    prefix: impl AsRef<Path>
) -> Result<LooseThenPacked<'p, 's>>

As iter(…), but filters by prefix, i.e. “refs/heads”.

Please note that “refs/heads` or “refs\heads” is equivalent to “refs/heads/”

impl Store

pub fn find_existing<'a, 'p, 's, Name, E>(
    &'s self,
    partial: Name,
    packed: Option<&'p Buffer>
) -> Result<Reference<'p>, Error> where
    Name: TryInto<PartialName<'a>, Error = E>,
    Error: From<E>, 

Similar to file::Store::find_existing() but a non-existing ref is treated as error.

pub fn loose_find_existing<'a, Name, E>(
    &self,
    partial: Name
) -> Result<Reference, Error> where
    Name: TryInto<PartialName<'a>, Error = E>,
    Error: From<E>, 

Similar to file::Store::find() won’t handle packed-refs.

impl Store

pub fn find<'a, 'p, 's, Name, E>(
    &'s self,
    partial: Name,
    packed: Option<&'p Buffer>
) -> Result<Option<Reference<'p>>, Error> where
    Name: TryInto<PartialName<'a>, Error = E>,
    Error: From<E>, 

Find a single reference by the given path which is required to be a valid reference name.

If packed is provided, the reference search will extend to the packed buffer created with packed(). Note that the caller is responsible for its freshness, i.e. assuring it wasn’t modified since it was read.

Returns Ok(None) if no such ref exists.

Note

The lookup algorithm follows the one in the git documentation.

pub fn loose_find<'a, Name, E>(
    &self,
    partial: Name
) -> Result<Option<Reference>, Error> where
    Name: TryInto<PartialName<'a>, Error = E>,
    Error: From<E>, 

Similar to file::Store::find() but a non-existing ref is treated as error.

impl Store

Edits

pub fn transaction(&self) -> Transaction<'_>

Open a transaction with the given edits, and determine how to fail if a lock cannot be obtained. A snapshot of packed references will be obtained automatically if needed to fulfill this transaction and will be provided as result of a successful transaction. Note that upon transaction failure, packed-refs will never have been altered.

impl Store

pub fn packed(&self) -> Result<Option<Buffer>, Error>

Return a buffer for the packed file

pub fn packed_refs_path(&self) -> PathBuf

Return the path at which packed-refs would usually be stored

Trait Implementations

impl Clone for Store

fn clone(&self) -> Store

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Store

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

Formats the value using the given formatter.

impl<P> From<P> for Store where
    P: Into<PathBuf>, 

fn from(path: P) -> Self

Performs the conversion.

impl Hash for Store

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, 

Feeds a slice of this type into the given Hasher.

impl Ord for Store

fn cmp(&self, other: &Store) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<Store> for Store

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialOrd<Store> for Store

fn partial_cmp(&self, other: &Store) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl Eq for Store

impl StructuralEq for Store

impl StructuralPartialEq for Store