gix_config/file/mutable/

multi_value.rs

use std::{collections::HashMap, ops::DerefMut};

use bstr::{BStr, BString, ByteVec};

use crate::{
    file::{
        self, SectionData, SectionId,
        mutable::{Whitespace, escape_value},
    },
    lookup,
    parse::{Event, section},
    value::normalize,
};

/// Internal data structure for [`MutableMultiValue`]
#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub(crate) struct EntryData {
    pub(crate) section_id: SectionId,
    pub(crate) offset_index: usize,
}

/// An intermediate representation of a mutable multivar obtained from a [`File`][crate::File].
#[derive(Debug)]
pub struct MultiValueMut<'borrow> {
    pub(crate) section: &'borrow mut HashMap<SectionId, SectionData>,
    pub(crate) backing: &'borrow mut Vec<u8>,
    pub(crate) key: section::ValueName,
    /// Each entry data struct provides sufficient information to index into
    /// [`Self::offsets`]. This layer of indirection is used for users to index
    /// into the offsets rather than leaking the internal data structures.
    pub(crate) indices_and_sizes: Vec<EntryData>,
    /// Each offset represents the size of a event slice and whether or not the
    /// event slice is significant or not. This is used to index into the
    /// actual section.
    pub(crate) offsets: HashMap<SectionId, Vec<usize>>,
}

impl MultiValueMut<'_> {
    /// Returns the actual values.
    pub fn get(&self) -> Result<Vec<BString>, lookup::existing::Error> {
        let mut expect_value = false;
        let mut values = Vec::new();
        let mut concatenated_value = BString::default();

        for EntryData {
            section_id,
            offset_index,
        } in &self.indices_and_sizes
        {
            let (offset, size) = MultiValueMut::index_and_size(&self.offsets, *section_id, *offset_index);
            for event in &self.section.get(section_id).expect("known section id").as_ref()[offset..offset + size] {
                match event {
                    Event::SectionValueName(section_key)
                        if section_key
                            .as_bstr_in(self.backing)
                            .eq_ignore_ascii_case(self.key.0.as_slice()) =>
                    {
                        expect_value = true;
                    }
                    Event::Value(v) if expect_value => {
                        expect_value = false;
                        values.push(normalize(v.as_slice_in(self.backing)).into_owned());
                    }
                    Event::ValueNotDone(v) if expect_value => concatenated_value.push_str(v.as_slice_in(self.backing)),
                    Event::ValueDone(v) if expect_value => {
                        expect_value = false;
                        concatenated_value.push_str(v.as_slice_in(self.backing));
                        let concatenated_value = std::mem::take(&mut concatenated_value);
                        values.push(normalize(&concatenated_value).into_owned());
                    }
                    _ => (),
                }
            }
        }

        if values.is_empty() {
            return Err(lookup::existing::Error::KeyMissing);
        }

        Ok(values)
    }

    /// Returns the amount of values within this multivar.
    #[must_use]
    pub fn len(&self) -> usize {
        self.indices_and_sizes.len()
    }

    /// Returns true if the multivar does not have any values.
    /// This might occur if the value was deleted but wasn't yet set with a new value.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.indices_and_sizes.is_empty()
    }

    /// Sets the value at the given index.
    ///
    /// # Safety
    ///
    /// This will panic if the index is out of range.
    pub fn set_string_at(&mut self, index: usize, value: impl AsRef<str>) -> Result<(), crate::parse::span::Error> {
        self.set_at(index, value.as_ref())
    }

    /// Sets the value at the given index.
    ///
    /// # Safety
    ///
    /// This will panic if the index is out of range.
    pub fn set_at(&mut self, index: usize, value: impl crate::AsBStr) -> Result<(), crate::parse::span::Error> {
        let EntryData {
            section_id,
            offset_index,
        } = self.indices_and_sizes[index];
        MultiValueMut::set_value_inner(
            &self.key,
            &mut self.offsets,
            &mut self.section.get_mut(&section_id).expect("known section id").body,
            self.backing,
            section_id,
            offset_index,
            value.as_bstr(),
        )
    }

    /// Sets all values to the provided ones. Note that this follows [`zip`]
    /// logic: if the number of values in the input is less than the number of
    /// values currently existing, then only the first `n` values are modified.
    /// If more values are provided than there currently are, then the
    /// remaining values are ignored.
    ///
    /// [`zip`]: std::iter::Iterator::zip
    pub fn set_values<Iter, Item>(&mut self, values: Iter) -> Result<(), crate::parse::span::Error>
    where
        Iter: IntoIterator<Item = Item>,
        Item: crate::AsBStr,
    {
        for (
            EntryData {
                section_id,
                offset_index,
            },
            value,
        ) in self.indices_and_sizes.iter().zip(values)
        {
            Self::set_value_inner(
                &self.key,
                &mut self.offsets,
                &mut self.section.get_mut(section_id).expect("known section id").body,
                self.backing,
                *section_id,
                *offset_index,
                value.as_bstr(),
            )?;
        }
        Ok(())
    }

    /// Sets all values in this multivar to the provided one without owning the
    /// provided input.
    pub fn set_all(&mut self, input: impl crate::AsBStr) -> Result<(), crate::parse::span::Error> {
        let input = input.as_bstr();
        for EntryData {
            section_id,
            offset_index,
        } in &self.indices_and_sizes
        {
            Self::set_value_inner(
                &self.key,
                &mut self.offsets,
                &mut self.section.get_mut(section_id).expect("known section id").body,
                self.backing,
                *section_id,
                *offset_index,
                input,
            )?;
        }
        Ok(())
    }

    fn set_value_inner(
        value_name: &section::ValueName,
        offsets: &mut HashMap<SectionId, Vec<usize>>,
        section: &mut file::section::BodyData,
        backing: &mut Vec<u8>,
        section_id: SectionId,
        offset_index: usize,
        value: &BStr,
    ) -> Result<(), crate::parse::span::Error> {
        let (offset, size) = MultiValueMut::index_and_size(offsets, section_id, offset_index);
        let whitespace = Whitespace::from_body(section, backing);
        let value = crate::parse::Span::append(backing, &escape_value(value))?;
        let key_sep_events = whitespace.key_value_separators(backing)?;
        let key = crate::parse::Span::append(backing, value_name.0.as_slice())?;

        let section = section.as_mut();
        section.drain(offset..offset + size);
        MultiValueMut::set_offset(offsets, section_id, offset_index, 2 + key_sep_events.len());
        section.insert(offset, Event::Value(value));
        section
            .splice(offset..offset, key_sep_events.into_iter().rev())
            .for_each(|_| {});
        section.insert(offset, Event::SectionValueName(key));
        Ok(())
    }

    /// Removes the value at the given index. Does nothing when called multiple
    /// times in succession.
    ///
    /// # Safety
    ///
    /// This will panic if the index is out of range.
    pub fn delete(&mut self, index: usize) {
        let EntryData {
            section_id,
            offset_index,
        } = &self.indices_and_sizes[index];
        let (offset, size) = MultiValueMut::index_and_size(&self.offsets, *section_id, *offset_index);
        if size == 0 {
            return;
        }
        self.section
            .get_mut(section_id)
            .expect("known section id")
            .body
            .as_mut()
            .drain(offset..offset + size);

        Self::set_offset(&mut self.offsets, *section_id, *offset_index, 0);
        self.indices_and_sizes.remove(index);
    }

    /// Removes all values. Does nothing when called multiple times in
    /// succession.
    pub fn delete_all(&mut self) {
        for EntryData {
            section_id,
            offset_index,
        } in &self.indices_and_sizes
        {
            let (offset, size) = MultiValueMut::index_and_size(&self.offsets, *section_id, *offset_index);
            if size == 0 {
                continue;
            }
            self.section
                .get_mut(section_id)
                .expect("known section id")
                .body
                .as_mut()
                .drain(offset..offset + size);
            Self::set_offset(&mut self.offsets, *section_id, *offset_index, 0);
        }
        self.indices_and_sizes.clear();
    }

    fn index_and_size(
        offsets: &HashMap<SectionId, Vec<usize>>,
        section_id: SectionId,
        offset_index: usize,
    ) -> (usize, usize) {
        offsets
            .get(&section_id)
            .expect("known section id")
            .iter()
            .take(offset_index + 1)
            .fold((0, 0), |(total_ofs, ofs), size| (total_ofs + ofs, *size))
    }

    // This must be an associated function rather than a method to allow Rust
    // to split mutable borrows.
    fn set_offset(
        offsets: &mut HashMap<SectionId, Vec<usize>>,
        section_id: SectionId,
        offset_index: usize,
        value: usize,
    ) {
        *offsets
            .get_mut(&section_id)
            .expect("known section id")
            .get_mut(offset_index)
            .unwrap()
            .deref_mut() = value;
    }
}