Trait Props 

pub trait Props {
    // Required method
    fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>
       where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>;

    // Provided methods
    fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>
       where K: ToStr { ... }
    fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>
       where V: FromValue<'kv>,
             K: ToStr { ... }
    fn and_props<U>(self, other: U) -> And<Self, U>
       where U: Props,
             Self: Sized { ... }
    fn filter<F>(self, filter: F) -> Filter<Self, F>
       where F: Fn(Str<'_>, Value<'_>) -> bool,
             Self: Sized { ... }
    fn collect<'kv, C>(&'kv self) -> C
       where C: FromProps<'kv> { ... }
    fn as_map(&self) -> &AsMap<Self>
       where Self: Sized { ... }
    fn dedup(&self) -> &Dedup<Self>
       where Self: Sized { ... }
    fn is_unique(&self) -> bool { ... }
    fn size(&self) -> Option<usize> { ... }
}

A collection of Str and Value pairs.

The Props::for_each method can be used to enumerate properties.

Uniqueness

Properties may be duplicated in a set of Props. When a property is duplicated, the first for a given key is the one to use.

Typed and untyped properties

The Props::get method will return a property as an untyped Value that can be formatted or serialized. If you’re looking for a specific type, you can use Props::pull instead.

Required Methods

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

Enumerate the Str and Value pairs.

The function for_each will be called for each property until all properties are visited, or it returns ControlFlow::Break.

Properties may be repeated, but can be de-duplicated by taking the first seen for a given key.

Provided Methods

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

Get the value for a given key, if it’s present.

If the key is present then this method will return Some. Otherwise this method will return None.

If the key appears multiple times, the first value seen should be returned.

Implementors are encouraged to override this method with a more efficient implementation.

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

Get the value for a given key, if it’s present as an instance of V.

If the key is present, and the raw value can be converted into V through Value::cast then this method will return Some. Otherwise this method will return None.

If the key appears multiple times, the first value seen should be returned.

fn and_props<U>(self, other: U) -> And<Self, U>

where U: Props, Self: Sized,

Concatenate other to the end of self.

fn filter<F>(self, filter: F) -> Filter<Self, F>

where F: Fn(Str<'_>, Value<'_>) -> bool, Self: Sized,

Filter the set of properties.

Only properties where the filter F returns true will be included.

fn collect<'kv, C>(&'kv self) -> C

where C: FromProps<'kv>,

Collect these properties into another collection type.

This method defers to the FromProps implementation on C.

fn as_map(&self) -> &AsMap<Self>

where Self: Sized,

Get an adapter that will serialize properties as a map.

fn dedup(&self) -> &Dedup<Self>

where Self: Sized,

Lazily de-duplicate properties in the collection.

Properties are de-duplicated by taking the first value for a given key.

fn is_unique(&self) -> bool

Whether the collection is known not to contain any duplicate keys.

If there’s any possibility a key may be duplicated, this method should return false.

fn size(&self) -> Option<usize>

A hint on the number of properties in the collection.

The returned size isn’t guaranteed to be exact, but should not be less than the number of times Props::for_each will call its given closure.

If the collection can’t determine its size without needing to walk its values then this method will return None.

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.

Implementations on Foreign Types

impl<'a, P> Props for &'a P

where P: Props + ?Sized,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<'a, P> Props for Box<P>

where P: Props + 'a + ?Sized,

Available on crate feature alloc only.

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<'a, P> Props for Arc<P>

where P: Props + 'a + ?Sized,

Available on crate feature alloc only.

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<K, V> Props for (K, V)

where K: ToStr, V: ToValue,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, G>(&'v self, key: G) -> Option<Value<'v>>

where G: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<K, V> Props for BTreeMap<K, V>

where K: Ord + ToStr + Borrow<str>, V: ToValue,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, Q>(&'v self, key: Q) -> Option<Value<'v>>

where Q: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<K, V> Props for HashMap<K, V>

where K: Eq + Hash + ToStr + Borrow<str>, V: ToValue,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, Q>(&'v self, key: Q) -> Option<Value<'v>>

where Q: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<P> Props for Option<P>

where P: Props,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<P> Props for [P]

where P: Props,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, G>(&'v self, key: G) -> Option<Value<'v>>

where G: ToStr,

fn size(&self) -> Option<usize>

impl<T> Props for Vec<T>

where T: Props,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

impl<T, const N: usize> Props for [T; N]

where [T]: Props,

fn for_each<'kv, F>(&'kv self, for_each: F) -> ControlFlow<()>

where F: FnMut(Str<'kv>, Value<'kv>) -> ControlFlow<()>,

fn get<'v, K>(&'v self, key: K) -> Option<Value<'v>>

where K: ToStr,

fn pull<'kv, V, K>(&'kv self, key: K) -> Option<V>

where V: FromValue<'kv>, K: ToStr,

fn is_unique(&self) -> bool

fn size(&self) -> Option<usize>

Implementors

impl Props for ThreadLocalCtxtFrame

impl Props for OwnedProps

impl Props for SpanCtxt

impl Props for Empty

impl Props for Extent

impl<'a> Props for dyn ErasedProps + 'a

impl<'a, P: Props> Props for Metric<'a, P>

impl<'a, P: Props> Props for Span<'a, P>

impl<A, B> Props for And<A, B>

where A: Props, B: Props,

impl<P> Props for AsMap<P>

where P: Props + ?Sized,

impl<P> Props for Dedup<P>

where P: Props + ?Sized,

impl<P, F> Props for Filter<P, F>

where P: Props, F: Fn(Str<'_>, Value<'_>) -> bool,