[dependencies]
indenter = "0.1.1"

    }
    pub fn member_ref<T: Any>(&self) -> Option<&T> {
        self.inner.member_ref()

    pub fn context<T: Any>(&self) -> Option<&T> {
        self.inner.context()

    pub fn member_mut<T: Any>(&mut self) -> Option<&mut T> {
        self.inner.member_mut()
    }
    pub fn context(&self) -> &C {
        &self.inner.context
    }
    pub fn context_mut(&mut self) -> &mut C {
        &mut self.inner.context

    pub fn context<T: Any>(&self) -> Option<&T> {

    pub fn member_ref<T: Any>(&self) -> Option<&T> {

            .context_raw(TypeId::of::<T>())?

            .member_ref(TypeId::of::<T>())?

    }
    pub fn member_mut<T: Any>(&mut self) -> Option<&mut T> {
        self.context
            .member_mut(TypeId::of::<T>())?
            .downcast_mut::<T>()

        self.context()

        self.member_ref()

use core::fmt::{self, Write};

use core::fmt;

}
pub(crate) struct Indented<'a, D> {
    pub(crate) inner: &'a mut D,
    pub(crate) number: Option<usize>,
    pub(crate) started: bool,

impl<T> Write for Indented<'_, T>
where
    T: Write,
{
    fn write_str(&mut self, s: &str) -> fmt::Result {
        for (i, line) in s.split('\n').enumerate() {
            if !self.started {
                self.started = true;
                match self.number {
                    Some(number) => write!(self.inner, "{: >5}: ", number)?,
                    None => self.inner.write_str("    ")?,
                }
            } else if i > 0 {
                self.inner.write_char('\n')?;
                if self.number.is_some() {
                    self.inner.write_str("       ")?;
                } else {
                    self.inner.write_str("    ")?;
                }
            }
            self.inner.write_str(line)?;
        }
        Ok(())
    }
}
#[cfg(test)]
mod tests {
    use super::*;
    use crate::alloc::String;
    #[test]
    fn one_digit() {
        let input = "verify\nthis";
        let expected = "    2: verify\n       this";
        let mut output = String::new();
        Indented {
            inner: &mut output,
            number: Some(2),
            started: false,
        }
        .write_str(input)
        .unwrap();
        assert_eq!(expected, output);
    }
    #[test]
    fn two_digits() {
        let input = "verify\nthis";
        let expected = "   12: verify\n       this";
        let mut output = String::new();
        Indented {
            inner: &mut output,
            number: Some(12),
            started: false,
        }
        .write_str(input)
        .unwrap();
        assert_eq!(expected, output);
    }
    #[test]
    fn no_digits() {
        let input = "verify\nthis";
        let expected = "    verify\n    this";
        let mut output = String::new();
        Indented {
            inner: &mut output,
            number: None,
            started: false,
        }
        .write_str(input)
        .unwrap();
        assert_eq!(expected, output);
    }
}

    fn member_ref(&self, _typeid: TypeId) -> Option<&dyn Any> {
        None
    }

    fn context_raw(&self, typeid: TypeId) -> Option<&dyn Any>;

    fn member_mut(&mut self, _typeid: TypeId) -> Option<&mut dyn Any> {
        None
    }

    fn context_raw(&self, typeid: TypeId) -> Option<&dyn Any> {

    fn member_ref(&self, typeid: TypeId) -> Option<&dyn Any> {

                let mut indented = fmt::Indented {
                    inner: f,
                    number: if multiple { Some(n) } else { None },
                    started: false,
                };
                write!(indented, "{}", error)?;

                if multiple {
                    write!(indenter::Indented::numbered(f, n), "{}", error)?;
                } else {
                    write!(indenter::Indented::new(f), "{}", error)?;
                }