Enum git_refspec::match_group::SourceRef

pub enum SourceRef<'a> {
    FullName(&'a BStr),
    ObjectId(ObjectId),
}

The source (or left-hand) side of a mapping, which references its name.

Variants

FullName(&'a BStr)

A full reference name, which is expected to be valid.

Validity, however, is not enforced here.

ObjectId(ObjectId)

The name of an object that is expected to exist on the remote side. Note that it might not be advertised by the remote but part of the object graph, and thus gets sent in the pack. The server is expected to fail unless the desired object is present but at some time it is merely a request by the user.

Implementations

impl SourceRef<'_>

pub fn to_owned(&self) -> Source

Create a fully owned instance from this one.

Examples found in repository

src/match_group/validate.rs (line 114)

    pub fn validated(mut self) -> Result<(Self, Vec<Fix>), Error> {
        let mut sources_by_destinations = BTreeMap::new();
        for (dst, (spec_index, src)) in self
            .mappings
            .iter()
            .filter_map(|m| m.rhs.as_ref().map(|dst| (dst.as_ref(), (m.spec_index, &m.lhs))))
        {
            let sources = sources_by_destinations.entry(dst).or_insert_with(Vec::new);
            if !sources.iter().any(|(_, lhs)| lhs == &src) {
                sources.push((spec_index, src))
            }
        }
        let mut issues = Vec::new();
        for (dst, conflicting_sources) in sources_by_destinations.into_iter().filter(|(_, v)| v.len() > 1) {
            issues.push(Issue::Conflict {
                destination_full_ref_name: dst.to_owned(),
                specs: conflicting_sources
                    .iter()
                    .map(|(spec_idx, _)| self.group.specs[*spec_idx].to_bstring())
                    .collect(),
                sources: conflicting_sources.into_iter().map(|(_, src)| src.to_owned()).collect(),
            })
        }
        if !issues.is_empty() {
            Err(Error { issues })
        } else {
            let mut fixed = Vec::new();
            let group = &self.group;
            self.mappings.retain(|m| match m.rhs.as_ref() {
                Some(dst) => {
                    if dst.starts_with(b"refs/") || dst.as_ref() == "HEAD" {
                        true
                    } else {
                        fixed.push(Fix::MappingWithPartialDestinationRemoved {
                            name: dst.as_ref().to_owned(),
                            spec: group.specs[m.spec_index].to_owned(),
                        });
                        false
                    }
                }
                None => true,
            });
            Ok((self, fixed))
        }
    }

Trait Implementations

impl<'a> Clone for SourceRef<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for SourceRef<'a>

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

Formats the value using the given formatter.

impl<'a> Hash for SourceRef<'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> PartialEq<SourceRef<'a>> for SourceRef<'a>

fn eq(&self, other: &SourceRef<'a>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Copy for SourceRef<'a>

impl<'a> Eq for SourceRef<'a>

impl<'a> StructuralEq for SourceRef<'a>

impl<'a> StructuralPartialEq for SourceRef<'a>