Struct git_ref::Reference

pub struct Reference {
    pub name: FullName,
    pub target: Target,
    pub peeled: Option<ObjectId>,
}

A fully owned backend agnostic reference

Fields

name: FullName

The path to uniquely identify this ref within its store.

target: Target

The target of the reference, either a symbolic reference by full name or a possibly intermediate object by its id.

peeled: Option<ObjectId>

The fully peeled object to which this reference ultimately points to. Only guaranteed to be set after peel_to_id_in_place() was called.

Implementations

impl Reference

pub fn kind(&self) -> Kind

Returns the kind of reference based on its target

pub fn name_without_namespace(
    &self,
    namespace: &Namespace
) -> Option<FullNameRef<'_>>

Return the full validated name of the reference, with the given namespace stripped if possible.

If the reference name wasn’t prefixed with namespace, None is returned instead.

pub fn strip_namespace(&mut self, namespace: &Namespace) -> &mut Self

Strip the given namespace from our name as well as the name, but not the reference we point to.

Trait Implementations

impl Clone for Reference

fn clone(&self) -> Reference

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Reference

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

Formats the value using the given formatter.

impl<'p> From<Reference<'p>> for Reference

fn from(value: Reference<'p>) -> Self

Converts to this type from the input type.

impl From<Reference> for Reference

fn from(value: Reference) -> Self

Converts to this type from the input type.

impl From<Reference> for Reference

fn from(value: Reference) -> Self

Converts to this type from the input type.

impl Hash for Reference

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 Reference

fn cmp(&self, other: &Reference) -> 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<Reference> for Reference

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

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

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

This method tests for !=.

impl PartialOrd<Reference> for Reference

fn partial_cmp(&self, other: &Reference) -> 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 ReferenceExt for Reference

fn log_iter<'a, 's>(&'a self, store: &'s Store) -> Platform<'a, 's>

A step towards obtaining forward or reverse iterators on reference logs.

fn log_exists(&self, store: &Store) -> bool

For details, see Reference::log_exists().

fn peel_to_id_in_place<E: Error + Send + Sync + 'static>(
    &mut self,
    store: &Store,
    find: impl FnMut(ObjectId, &mut Vec<u8>) -> Result<Option<(Kind, &[u8])>, E>
) -> Result<ObjectId, Error>

For details, see Reference::peel_to_id_in_place().

fn peel_to_id_in_place_packed<E: Error + Send + Sync + 'static>(
    &mut self,
    store: &Store,
    find: impl FnMut(ObjectId, &mut Vec<u8>) -> Result<Option<(Kind, &[u8])>, E>,
    packed: Option<&Buffer>
) -> Result<ObjectId, Error>

For details, see Reference::peel_to_id_in_place(), with support for a known stable packed buffer.

fn follow(&self, store: &Store) -> Option<Result<Reference, Error>>

Follow this symbolic reference one level and return the ref it refers to.

fn follow_packed(
    &self,
    store: &Store,
    packed: Option<&Buffer>
) -> Option<Result<Reference, Error>>

Follow this symbolic reference one level and return the ref it refers to, possibly providing access to packed references for lookup if it contains the referent.

impl Eq for Reference

impl StructuralEq for Reference

impl StructuralPartialEq for Reference