Struct tracing_tunnel::TracedValues

pub struct TracedValues<S> { /* private fields */ }

Collection of named TracedValues.

Functionally this collection is similar to a HashMap<S, TracedValue>, with the key difference being that the order of iteration is the insertion order. If a value is updated, including via Extend etc., it preserves its old placement.

Implementations

impl<S: From<&'static str> + AsRef<str>> TracedValues<S>

pub fn from_values(values: &ValueSet<'_>) -> Self

Creates traced values from the specified value set.

pub fn from_record(values: &Record<'_>) -> Self

Creates traced values from the specified record.

pub fn from_event(event: &Event<'_>) -> Self

Creates traced values from the values in the specified event.

impl<S: AsRef<str>> TracedValues<S>

pub fn new() -> Self

Creates new empty values.

pub fn len(&self) -> usize

Returns the number of stored values.

pub fn is_empty(&self) -> bool

Checks whether this collection of values is empty.

pub fn get(&self, name: &str) -> Option<&TracedValue>

Returns the value with the specified name, or None if it not set.

pub fn iter(&self) -> TracedValuesIter<'_, S>

Iterates over the contained name-value pairs.

pub fn insert(&mut self, name: S, value: TracedValue) -> Option<TracedValue>

Inserts a value with the specified name. If a value with the same name was present previously, it is overwritten. Returns the previous value with the specified name, if any.

Trait Implementations

impl<S: Clone> Clone for TracedValues<S>

fn clone(&self) -> TracedValues<S>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<S: AsRef<str>> Debug for TracedValues<S>

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<S> Default for TracedValues<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for TracedValues<String>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: AsRef<str>> Extend<(S, TracedValue)> for TracedValues<S>

fn extend<I: IntoIterator<Item = (S, TracedValue)>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: AsRef<str>> FromIterator<(S, TracedValue)> for TracedValues<S>

fn from_iter<I: IntoIterator<Item = (S, TracedValue)>>(iter: I) -> Self

Creates a value from an iterator.

impl<S: AsRef<str>> Index<&str> for TracedValues<S>

type Output = TracedValue

The returned type after indexing.

fn index(&self, index: &str) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, S: AsRef<str>> IntoIterator for &'a TracedValues<S>

type Item = (&'a str, &'a TracedValue)

The type of the elements being iterated over.

type IntoIter = TracedValuesIter<'a, S>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S> IntoIterator for TracedValues<S>

type Item = (S, TracedValue)

The type of the elements being iterated over.

type IntoIter = IntoIter<(S, TracedValue)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S: AsRef<str>> Serialize for TracedValues<S>

fn serialize<Ser: Serializer>( &self, serializer: Ser, ) -> Result<Ser::Ok, Ser::Error>

Serialize this value into the given Serde serializer.