gix_protocol/fetch/refmap/
mod.rs

1///
2#[cfg(any(feature = "blocking-client", feature = "async-client"))]
3pub mod init;
4
5/// Either an object id that the remote has or the matched remote ref itself.
6#[derive(Debug, Clone)]
7pub enum Source {
8    /// An object id, as the matched ref-spec was an object id itself.
9    ObjectId(gix_hash::ObjectId),
10    /// The remote reference that matched the ref-specs name.
11    Ref(crate::handshake::Ref),
12}
13
14impl Source {
15    /// Return either the direct object id we refer to or the direct target that a reference refers to.
16    /// The latter may be a direct or a symbolic reference.
17    /// If unborn, `None` is returned.
18    pub fn as_id(&self) -> Option<&gix_hash::oid> {
19        match self {
20            Source::ObjectId(id) => Some(id),
21            Source::Ref(r) => r.unpack().1,
22        }
23    }
24
25    /// Return the target that this symbolic ref is pointing to, or `None` if it is no symbolic ref.
26    pub fn as_target(&self) -> Option<&bstr::BStr> {
27        match self {
28            Source::ObjectId(_) => None,
29            Source::Ref(r) => match r {
30                crate::handshake::Ref::Peeled { .. } | crate::handshake::Ref::Direct { .. } => None,
31                crate::handshake::Ref::Symbolic { target, .. } | crate::handshake::Ref::Unborn { target, .. } => {
32                    Some(target.as_ref())
33                }
34            },
35        }
36    }
37
38    /// Returns the peeled id of this instance, that is the object that can't be de-referenced anymore.
39    pub fn peeled_id(&self) -> Option<&gix_hash::oid> {
40        match self {
41            Source::ObjectId(id) => Some(id),
42            Source::Ref(r) => {
43                let (_name, target, peeled) = r.unpack();
44                peeled.or(target)
45            }
46        }
47    }
48
49    /// Return ourselves as the full name of the reference we represent, or `None` if this source isn't a reference but an object.
50    pub fn as_name(&self) -> Option<&bstr::BStr> {
51        match self {
52            Source::ObjectId(_) => None,
53            Source::Ref(r) => match r {
54                crate::handshake::Ref::Unborn { full_ref_name, .. }
55                | crate::handshake::Ref::Symbolic { full_ref_name, .. }
56                | crate::handshake::Ref::Direct { full_ref_name, .. }
57                | crate::handshake::Ref::Peeled { full_ref_name, .. } => Some(full_ref_name.as_ref()),
58            },
59        }
60    }
61}
62
63/// An index into various lists of refspecs that have been used in a [Mapping] of remote references to local ones.
64#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
65pub enum SpecIndex {
66    /// An index into the _refspecs of the remote_ that triggered a fetch operation.
67    /// These refspecs are explicit and visible to the user.
68    ExplicitInRemote(usize),
69    /// An index into the list of [extra refspecs](crate::fetch::RefMap::extra_refspecs) that are implicit
70    /// to a particular fetch operation.
71    Implicit(usize),
72}
73
74impl SpecIndex {
75    /// Depending on our index variant, get the index either from `refspecs` or from `extra_refspecs` for `Implicit` variants.
76    pub fn get<'a>(
77        self,
78        refspecs: &'a [gix_refspec::RefSpec],
79        extra_refspecs: &'a [gix_refspec::RefSpec],
80    ) -> Option<&'a gix_refspec::RefSpec> {
81        match self {
82            SpecIndex::ExplicitInRemote(idx) => refspecs.get(idx),
83            SpecIndex::Implicit(idx) => extra_refspecs.get(idx),
84        }
85    }
86
87    /// If this is an `Implicit` variant, return its index.
88    pub fn implicit_index(self) -> Option<usize> {
89        match self {
90            SpecIndex::Implicit(idx) => Some(idx),
91            SpecIndex::ExplicitInRemote(_) => None,
92        }
93    }
94}
95
96/// A mapping between a single remote reference and its advertised objects to a local destination which may or may not exist.
97#[derive(Debug, Clone)]
98pub struct Mapping {
99    /// The reference on the remote side, along with information about the objects they point to as advertised by the server.
100    pub remote: Source,
101    /// The local tracking reference to update after fetching the object visible via `remote`.
102    pub local: Option<bstr::BString>,
103    /// The index into the fetch ref-specs used to produce the mapping, allowing it to be recovered.
104    pub spec_index: SpecIndex,
105}
gix_protocol/fetch/refmap/mod.rs

gix_protocol/fetch/refmap/
mod.rs
