pub fn follows_from(&self, from: &Id) -> &Self {
        if let Some(ref inner) = self.inner {
            inner.follows_from(from);
        }
        self
    }
/// Indicates that the span with the given ID has an indirect causal
/// relationship with this span.
///
/// This relationship differs somewhat from the parent-child relationship: a
/// span may have any number of prior spans, rather than a single one; and
/// spans are not considered to be executing _inside_ of the spans they
/// follow from. This means that a span may close even if subsequent spans
/// that follow from it are still open, and time spent inside of a
/// subsequent span should not be included in the time its precedents were
/// executing. This is used to model causal relationships such as when a
/// single future spawns several related background tasks, et cetera.
///
/// If this span is disabled, or the resulting follows-from relationship
/// would be invalid, this function will do nothing.
Indicates that the span with the given ID has an indirect causal
relationship with this span.

This relationship differs somewhat from the parent-child relationship: a
span may have any number of prior spans, rather than a single one; and
spans are not considered to be executing _inside_ of the spans they
follow from. This means that a span may close even if subsequent spans
that follow from it are still open, and time spent inside of a
subsequent span should not be included in the time its precedents were
executing. This is used to model causal relationships such as when a
single future spawns several related background tasks, et cetera.

If this span is disabled, or the resulting follows-from relationship
would be invalid, this function will do nothing.
Indicates that the span with the given ID has an indirect causal relationship with this span . This relationship differs somewhat from the parent - child relationship : a span may have any number of prior spans rather than a single one ; and spans are not considered to be executing _inside_ of the spans they follow from . This means that a span may close even if subsequent spans that follow from it are still open and time spent inside of a subsequent span should not be included in the time its precedents were executing . This is used to model causal relationships such as when a single future spawns several related background tasks et cetera . If this span is disabled or the resulting follows - from relationship would be invalid this function will do nothing .
pub fn follows_from(&self, from: &Id) -> &Self {
        if let Some(ref inner) = self.inner {
            inner.follows_from(from);
        }
        self
    }
pub fn follows_from ( & self , from : & Id ) -> & Self { if let Some ( ref inner ) = self . inner { inner . follows_from ( from ) ; } self }
Indicates that the span with the given ID has an indirect causal
relationship with this span.
Indicates that the span with the given ID has an indirect causal relationship with this span .
&self
from
&Id