use std::fmt::Display; use bstr::{BStr, BString}; use crate::parse::{Event, EventRef}; impl Event {    /// Shift all backing-buffer spans in this event forward by `offset` bytes.    pub(crate) fn rebase(&mut self, offset: usize) -> Result<(), crate::parse::span::Error> {        match self {            Event::Comment(comment) => comment.text.rebase(offset),            Event::SectionHeader(header) => header.rebase(offset),            Event::SectionValueName(name) => name.rebase(offset),            Event::Value(bytes)            | Event::Newline(bytes)            | Event::ValueNotDone(bytes)            | Event::ValueDone(bytes)            | Event::Whitespace(bytes) => bytes.rebase(offset),            Event::KeyValueSeparator => Ok(()),        }    }     pub(crate) fn copy_to_backing_in(        &self,        source: &[u8],        target: &mut Vec<u8>,    ) -> Result<Event, crate::parse::span::Error> {        Ok(match self {            Event::Comment(comment) => Event::Comment(comment.copy_to_backing_in(source, target)?),            Event::SectionHeader(header) => Event::SectionHeader(header.copy_to_backing_in(source, target)?),            Event::SectionValueName(name) => Event::SectionValueName(name.copy_to_backing_in(source, target)?),            Event::Value(bytes) => Event::Value(bytes.copy_to_backing_in(source, target)?),            Event::Newline(bytes) => Event::Newline(bytes.copy_to_backing_in(source, target)?),            Event::ValueNotDone(bytes) => Event::ValueNotDone(bytes.copy_to_backing_in(source, target)?),            Event::ValueDone(bytes) => Event::ValueDone(bytes.copy_to_backing_in(source, target)?),            Event::Whitespace(bytes) => Event::Whitespace(bytes.copy_to_backing_in(source, target)?),            Event::KeyValueSeparator => Event::KeyValueSeparator,        })    }     /// Resolve this event against `backing` without allocating.    pub(crate) fn as_ref_in<'a>(&'a self, backing: &'a [u8]) -> EventRef<'a> {        match self {            Event::Comment(comment) => EventRef::Comment {                tag: comment.tag,                text: comment.text.as_bstr_in(backing),            },            Event::SectionHeader(header) => EventRef::SectionHeader {                name: header.name.as_bstr_in(backing),                separator: header.separator.as_ref().map(|separator| separator.as_bstr_in(backing)),                subsection_name: header                    .subsection_name                    .as_ref()                    .map(|subsection_name| subsection_name.value_in(backing)),            },            Event::SectionValueName(name) => EventRef::SectionValueName(name.as_bstr_in(backing)),            Event::Value(bytes) => EventRef::Value(bytes.as_bstr_in(backing)),            Event::Newline(bytes) => EventRef::Newline(bytes.as_bstr_in(backing)),            Event::ValueNotDone(bytes) => EventRef::ValueNotDone(bytes.as_bstr_in(backing)),            Event::ValueDone(bytes) => EventRef::ValueDone(bytes.as_bstr_in(backing)),            Event::Whitespace(bytes) => EventRef::Whitespace(bytes.as_bstr_in(backing)),            Event::KeyValueSeparator => EventRef::KeyValueSeparator,        }    }     /// Return the event's principal byte payload resolved against `backing`, without allocating.    ///    /// This is lossy for events whose serialized representation consists of multiple pieces:    /// section headers omit their brackets, separator, and subsection; comments omit their marker;    /// and continued values omit their trailing backslash. Use [`Self::write_to_in()`] when the    /// complete serialized event is required.    pub(crate) fn to_bstr_lossy_in<'a>(&'a self, backing: &'a [u8]) -> &'a BStr {        match self {            Self::ValueNotDone(e) | Self::Whitespace(e) | Self::Newline(e) | Self::Value(e) | Self::ValueDone(e) => {                e.as_bstr_in(backing)            }            Self::KeyValueSeparator => "=".into(),            Self::SectionValueName(k) => k.as_bstr_in(backing),            Self::SectionHeader(h) => h.name.as_bstr_in(backing),            Self::Comment(c) => c.text.as_bstr_in(backing),        }    }     pub(crate) fn write_to_in(&self, backing: &[u8], out: &mut dyn std::io::Write) -> std::io::Result<()> {        match self {            Self::ValueNotDone(e) => {                out.write_all(e.as_slice_in(backing))?;                out.write_all(br"\")            }            Self::Whitespace(e) | Self::Newline(e) | Self::Value(e) | Self::ValueDone(e) => {                out.write_all(e.as_slice_in(backing))            }            Self::KeyValueSeparator => out.write_all(b"="),            Self::SectionValueName(k) => out.write_all(k.as_slice_in(backing)),            Self::SectionHeader(h) => h.write_to_in(backing, out),            Self::Comment(c) => c.write_to_in(backing, out),        }    }} impl EventRef<'_> {    /// Turn ourselves into the text we represent, lossy.    ///    /// Note that this mirrors `Event::to_bstr_lossy_in()`.    pub fn to_bstr_lossy(&self) -> &BStr {        match self {            EventRef::ValueNotDone(bytes)            | EventRef::Whitespace(bytes)            | EventRef::Newline(bytes)            | EventRef::Value(bytes)            | EventRef::ValueDone(bytes) => bytes,            EventRef::KeyValueSeparator => "=".into(),            EventRef::SectionValueName(name) => name,            EventRef::SectionHeader { name, .. } => name,            EventRef::Comment { text, .. } => text,        }    }     /// Stream ourselves to the given `out`, reproducing this event mostly losslessly.    ///    /// Quoted subsection names are the exception: [`EventRef::SectionHeader`] contains the decoded    /// subsection name, so this method escapes it again and may normalize its original escape    /// spelling. The resulting header has the same subsection name, but may not be byte-for-byte    /// identical to the parsed input.    pub fn write_to(&self, out: &mut dyn std::io::Write) -> std::io::Result<()> {        match self {            EventRef::ValueNotDone(bytes) => {                out.write_all(bytes)?;                out.write_all(br"\")            }            EventRef::Whitespace(bytes)            | EventRef::Newline(bytes)            | EventRef::Value(bytes)            | EventRef::ValueDone(bytes) => out.write_all(bytes),            EventRef::KeyValueSeparator => out.write_all(b"="),            EventRef::SectionValueName(name) => out.write_all(name),            EventRef::SectionHeader {                name,                separator,                subsection_name,            } => {                out.write_all(b"[")?;                out.write_all(name)?;                if let (Some(separator), Some(subsection_name)) = (separator, subsection_name) {                    out.write_all(separator)?;                    if *separator == b"." {                        out.write_all(subsection_name)?;                    } else {                        out.write_all(b"\"")?;                        crate::parse::section::header::write_escaped_subsection(subsection_name, &mut *out)?;                        out.write_all(b"\"")?;                    }                }                out.write_all(b"]")            }            EventRef::Comment { tag, text } => {                out.write_all(&[*tag])?;                out.write_all(text)            }        }    }} impl Display for EventRef<'_> {    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {        Display::fmt(&BString::from(self), f)    }} impl From<&EventRef<'_>> for BString {    fn from(event: &EventRef<'_>) -> Self {        let mut buf = Vec::new();        event.write_to(&mut buf).expect("io error impossible");        buf.into()    }}