Trait Inspector

pub trait Inspector: Sized {
    type ChildInspector<'a>: Inspector;

    // Required methods
    fn record_child<F>(&mut self, name: &str, f: F)
       where F: FnOnce(&mut Self::ChildInspector<'_>);
    fn record_unnamed_child<F>(&mut self, f: F)
       where F: FnOnce(&mut Self::ChildInspector<'_>);
    fn record_usize<T>(&mut self, name: &str, value: T)
       where T: Into<usize>;
    fn record_uint<T>(&mut self, name: &str, value: T)
       where T: Into<u64>;
    fn record_int<T>(&mut self, name: &str, value: T)
       where T: Into<i64>;
    fn record_double<T>(&mut self, name: &str, value: T)
       where T: Into<f64>;
    fn record_str(&mut self, name: &str, value: &str);
    fn record_string(&mut self, name: &str, value: String);
    fn record_bool(&mut self, name: &str, value: bool);

    // Provided methods
    fn record_display_child<T, F>(&mut self, name: T, f: F)
       where T: Display,
             F: FnOnce(&mut Self::ChildInspector<'_>) { ... }
    fn record_debug_child<T, F>(&mut self, name: T, f: F)
       where T: Debug,
             F: FnOnce(&mut Self::ChildInspector<'_>) { ... }
    fn record_display<T>(&mut self, name: &str, value: T)
       where T: Display { ... }
    fn record_debug<T>(&mut self, name: &str, value: T)
       where T: Debug { ... }
    fn record_ip_addr<A>(&mut self, name: &str, value: A)
       where A: IpAddress { ... }
    fn record_inspectable_value<V>(&mut self, name: &str, value: &V)
       where V: InspectableValue { ... }
    fn record_instant<V>(&mut self, name: InstantPropertyName, value: &V)
       where V: InspectableInstant { ... }
    fn record_inspectable<V>(&mut self, name: &str, value: &V)
       where V: Inspectable { ... }
    fn delegate_inspectable<V>(&mut self, value: &V)
       where V: Inspectable { ... }
}

A trait abstracting a state inspector.

This trait follows roughly the same shape as the API provided by the fuchsia_inspect crate, but we abstract it out so not to take the dependency.

Given we have the trait, we can fill it in with some helpful default implementations for common types that are exposed as well, like IP addresses and such.

Required Associated Types

type ChildInspector<'a>: Inspector

The type given to record contained children.

Required Methods

fn record_child<F>(&mut self, name: &str, f: F)

where F: FnOnce(&mut Self::ChildInspector<'_>),

Records a nested inspector with name calling f with the nested child to be filled in.

This is used to group and contextualize data.

fn record_unnamed_child<F>(&mut self, f: F)

where F: FnOnce(&mut Self::ChildInspector<'_>),

Records a child without a name.

The Inpector is expected to keep track of the number of unnamed children and allocate names appropriately from that.

fn record_usize<T>(&mut self, name: &str, value: T)

where T: Into<usize>,

Records anything that can be represented by a usize.

fn record_uint<T>(&mut self, name: &str, value: T)

where T: Into<u64>,

Records anything that can be represented by a u64.

fn record_int<T>(&mut self, name: &str, value: T)

where T: Into<i64>,

Records anything that can be represented by a i64.

fn record_double<T>(&mut self, name: &str, value: T)

where T: Into<f64>,

Records anything that can be represented by a f64.

fn record_str(&mut self, name: &str, value: &str)

Records a str value.

fn record_string(&mut self, name: &str, value: String)

Records an owned string.

fn record_bool(&mut self, name: &str, value: bool)

Records a boolean.

Provided Methods

fn record_display_child<T, F>(&mut self, name: T, f: F)

where T: Display, F: FnOnce(&mut Self::ChildInspector<'_>),

Records a child whose name is the display implementation of T.

fn record_debug_child<T, F>(&mut self, name: T, f: F)

where T: Debug, F: FnOnce(&mut Self::ChildInspector<'_>),

Records a child whose name is the Debug implementation of T.

fn record_display<T>(&mut self, name: &str, value: T)

where T: Display,

Records a value that implements Display as its display string.

fn record_debug<T>(&mut self, name: &str, value: T)

where T: Debug,

Records a value that implements Debug as its debug string.

fn record_ip_addr<A>(&mut self, name: &str, value: A)

where A: IpAddress,

Records an IP address.

fn record_inspectable_value<V>(&mut self, name: &str, value: &V)

where V: InspectableValue,

Records an implementor of InspectableValue.

fn record_instant<V>(&mut self, name: InstantPropertyName, value: &V)

where V: InspectableInstant,

Records an implementor of InspectableInstant.

fn record_inspectable<V>(&mut self, name: &str, value: &V)

where V: Inspectable,

Records an implementor of Inspectable under name.

fn delegate_inspectable<V>(&mut self, value: &V)

where V: Inspectable,

Delegates more fields to be added by an Inspectable implementation.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, D> Inspector for FuchsiaInspector<'a, D>

type ChildInspector<'l> = FuchsiaInspector<'l, D>