Struct git_config::file::section::Body

pub struct Body<'event>(_);

A opaque type that represents a section body.

Implementations

impl<'event> Body<'event>

Access

pub fn value(&self, key: impl AsRef<str>) -> Option<Cow<'_, BStr>>

Retrieves the last matching value in a section with the given key, if present.

Note that we consider values without key separator = non-existing.

Examples found in repository

src/file/access/raw.rs (line 50)

    pub fn raw_value_filter(
        &self,
        section_name: impl AsRef<str>,
        subsection_name: Option<&BStr>,
        key: impl AsRef<str>,
        filter: &mut MetadataFilter,
    ) -> Result<Cow<'_, BStr>, lookup::existing::Error> {
        let section_ids = self.section_ids_by_name_and_subname(section_name.as_ref(), subsection_name)?;
        let key = key.as_ref();
        for section_id in section_ids.rev() {
            let section = self.sections.get(&section_id).expect("known section id");
            if !filter(section.meta()) {
                continue;
            }
            if let Some(v) = section.value(key) {
                return Ok(v);
            }
        }

        Err(lookup::existing::Error::KeyMissing)
    }

pub fn value_implicit(
    &self,
    key: impl AsRef<str>
) -> Option<Option<Cow<'_, BStr>>>

Retrieves the last matching value in a section with the given key, if present, and indicates an implicit value with Some(None), and a non-existing one as None

Examples found in repository

src/file/section/body.rs (line 21)

    pub fn value(&self, key: impl AsRef<str>) -> Option<Cow<'_, BStr>> {
        self.value_implicit(key).flatten()
    }

src/file/access/comfort.rs (line 129)

    pub fn boolean_filter(
        &self,
        section_name: impl AsRef<str>,
        subsection_name: Option<&BStr>,
        key: impl AsRef<str>,
        filter: &mut MetadataFilter,
    ) -> Option<Result<bool, value::Error>> {
        let section_name = section_name.as_ref();
        let section_ids = self
            .section_ids_by_name_and_subname(section_name, subsection_name)
            .ok()?;
        let key = key.as_ref();
        for section_id in section_ids.rev() {
            let section = self.sections.get(&section_id).expect("known section id");
            if !filter(section.meta()) {
                continue;
            }
            match section.value_implicit(key) {
                Some(Some(v)) => return Some(crate::Boolean::try_from(v).map(|b| b.into())),
                Some(None) => return Some(Ok(true)),
                None => continue,
            }
        }
        None
    }

pub fn values(&self, key: impl AsRef<str>) -> Vec<Cow<'_, BStr>>

Retrieves all values that have the provided key name. This may return an empty vec, which implies there were no values with the provided key.

Examples found in repository

src/file/includes/mod.rs (line 135)

fn detach_include_paths(
    include_paths: &mut Vec<(SectionId, crate::Path<'static>)>,
    section: &file::Section<'_>,
    id: SectionId,
) {
    include_paths.extend(
        section
            .body
            .values("path")
            .into_iter()
            .map(|path| (id, crate::Path::from(Cow::Owned(path.into_owned())))),
    )
}

src/file/access/raw.rs (line 202)

    pub fn raw_values_filter(
        &self,
        section_name: impl AsRef<str>,
        subsection_name: Option<&BStr>,
        key: impl AsRef<str>,
        filter: &mut MetadataFilter,
    ) -> Result<Vec<Cow<'_, BStr>>, lookup::existing::Error> {
        let mut values = Vec::new();
        let section_ids = self.section_ids_by_name_and_subname(section_name.as_ref(), subsection_name)?;
        let key = key.as_ref();
        for section_id in section_ids {
            let section = self.sections.get(&section_id).expect("known section id");
            if !filter(section.meta()) {
                continue;
            }
            values.extend(section.values(key));
        }

        if values.is_empty() {
            Err(lookup::existing::Error::KeyMissing)
        } else {
            Ok(values)
        }
    }

pub fn keys(&self) -> impl Iterator<Item = &Key<'event>>

Returns an iterator visiting all keys in order.

pub fn contains_key(&self, key: impl AsRef<str>) -> bool

Returns true if the section containss the provided key.

pub fn num_values(&self) -> usize

Returns the number of values in the section.

Examples found in repository

src/file/access/read_only.rs (line 272)

    pub fn num_values(&self) -> usize {
        self.sections.values().map(|section| section.num_values()).sum()
    }

pub fn is_void(&self) -> bool

Returns if the section is empty. Note that this may count whitespace, see num_values() for another way to determine semantic emptiness.

Examples found in repository

src/file/access/read_only.rs (line 280)

    pub fn is_void(&self) -> bool {
        self.sections.values().all(|s| s.body.is_void())
    }

Trait Implementations

impl<'event> Clone for Body<'event>

fn clone(&self) -> Body<'event>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'event> Debug for Body<'event>

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

Formats the value using the given formatter.

impl<'event> Default for Body<'event>

fn default() -> Body<'event>

Returns the “default value” for a type.

impl<'event> Hash for Body<'event>

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<'event> IntoIterator for Body<'event>

type Item = (Key<'event>, Cow<'event, BStr>)

The type of the elements being iterated over.

type IntoIter = BodyIter<'event>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'event> Ord for Body<'event>

fn cmp(&self, other: &Body<'event>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<'event> PartialEq<Body<'event>> for Body<'event>

fn eq(&self, other: &Body<'event>) -> 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<'event> PartialOrd<Body<'event>> for Body<'event>

fn partial_cmp(&self, other: &Body<'event>) -> 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<'event> Eq for Body<'event>

impl<'event> StructuralEq for Body<'event>

impl<'event> StructuralPartialEq for Body<'event>