//! A crate for handling the references stored in various formats in a git repository.//!//! References are also called _refs_ which are used interchangeably.//!//! Refs are the way to keep track of objects and come in two flavors.//!//! * symbolic refs are pointing to another reference//! * peeled refs point to the an object by its [ObjectId][git_hash::ObjectId]//!//! They can be identified by a relative path and stored in various flavors.//!//! * **files**//!   * **[loose][file::Store]**//!     * one reference maps to a file on disk//!   * **packed**//!     * references are stored in a single human-readable file, along with their targets if they are symbolic.//! * **ref-table**//!   * supersedes all of the above to allow handling hundreds of thousands of references.#![forbid(unsafe_code)]#![deny(missing_docs, rust_2018_idioms)]use bstr::BStr;use git_hash::oid; mod store;pub use store::{file, packed};///pub mod mutable;///pub mod name;///pub mod transaction; /// A validated and potentially partial reference name - it can safely be used for common operations.#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]pub struct FullName<'a>(&'a BStr);/// A validated complete and fully qualified reference name, safe to use for all operations.#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]pub struct PartialName<'a>(&'a BStr); /// Denotes the kind of reference.#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]#[cfg_attr(feature = "serde1", derive(serde::Serialize, serde::Deserialize))]pub enum Kind {    /// A ref that points to an object id    Peeled,    /// A ref that points to another reference, adding a level of indirection.    ///    /// It can be resolved to an id using the [`peel_in_place_to_id()`][file::Reference::peel_to_id_in_place()] method.    Symbolic,} /// Denotes a ref target, equivalent to [`Kind`], but with immutable data.#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]pub enum Target<'a> {    /// A ref that points to an object id    Peeled(&'a oid),    /// A ref that points to another reference by its validated name, adding a level of indirection.    Symbolic(&'a BStr),} mod target {    use crate::{Kind, Target};    use bstr::BStr;    use git_hash::oid;     impl<'a> Target<'a> {        /// Returns the kind of the target the ref is pointing to.        pub fn kind(&self) -> Kind {            match self {                Target::Symbolic(_) => Kind::Symbolic,                Target::Peeled(_) => Kind::Peeled,            }        }        /// Interpret this target as object id which maybe `None` if it is symbolic.        pub fn as_id(&self) -> Option<&oid> {            match self {                Target::Symbolic(_) => None,                Target::Peeled(oid) => Some(oid),            }        }        /// Interpret this target as name of the reference it points to which maybe `None` if it an object id.        pub fn as_name(&self) -> Option<&BStr> {            match self {                Target::Symbolic(path) => Some(path),                Target::Peeled(_) => None,            }        }        /// Convert this instance into an owned version, without consuming it.        pub fn to_owned(self) -> crate::mutable::Target {            self.into()        }    }} mod parse {    use bstr::{BStr, ByteSlice};    use nom::{        branch::alt,        bytes::complete::{tag, take_while_m_n},        error::ParseError,        IResult,    };     fn is_hex_digit_lc(b: u8) -> bool {        matches!(b, b'0'..=b'9' | b'a'..=b'f')    }     /// Copy from https://github.com/Byron/gitoxide/blob/f270850ff92eab15258023b8e59346ec200303bd/git-object/src/immutable/parse.rs#L64    pub fn hex_hash<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a BStr, E> {        take_while_m_n(            git_hash::Kind::shortest().len_in_hex(),            git_hash::Kind::longest().len_in_hex(),            is_hex_digit_lc,        )(i)        .map(|(i, hex)| (i, hex.as_bstr()))    }     pub fn newline<'a, E: ParseError<&'a [u8]>>(i: &'a [u8]) -> IResult<&'a [u8], &'a [u8], E> {        alt((tag(b"\r\n"), tag(b"\n")))(i)    }}