SYMBOL INDEX (175 symbols across 24 files)

FILE: await-tree-attributes/src/lib.rs
  type InstrumentArgs (line 23) | struct InstrumentArgs {
    method parse (line 30) | fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
  function instrument (line 132) | pub fn instrument(args: TokenStream, input: TokenStream) -> TokenStream {

FILE: await-tree-attributes/tests/expansion.rs
  function test_expansion (line 21) | async fn test_expansion(value: i32) -> i32 {
  function test_attribute_expansion (line 26) | async fn test_attribute_expansion() {
  function no_args_function (line 34) | async fn no_args_function() -> String {
  function test_no_args_expansion (line 39) | async fn test_no_args_expansion() {
  function long_running_task (line 46) | async fn long_running_task(id: u32) -> u32 {
  function verbose_task (line 52) | async fn verbose_task() -> String {
  function complex_task (line 58) | async fn complex_task(name: &str, value: i32) -> String {
  function keywords_only_task (line 64) | async fn keywords_only_task() -> i32 {
  function test_keywords (line 69) | async fn test_keywords() {
  function boxed_task (line 85) | async fn boxed_task(value: i32) -> i32 {
  function boxed_long_running_task (line 91) | async fn boxed_long_running_task() -> String {
  function boxed_no_args_task (line 97) | async fn boxed_no_args_task() -> i32 {
  function test_boxed_keyword (line 102) | async fn test_boxed_keyword() {

FILE: await-tree-attributes/tests/integration.rs
  function test_function (line 19) | async fn test_function(arg1: i32, arg2: String) -> i32 {
  function simple_function (line 26) | async fn simple_function() -> String {
  function complex_function (line 33) | async fn complex_function(name: &str, value: u64) -> String {
  function test_instrument_attribute (line 39) | async fn test_instrument_attribute() {
  function public_function (line 55) | pub async fn public_function() -> i32 {
  function private_function (line 61) | async fn private_function() -> i32 {
  function test_visibility_and_attributes (line 66) | async fn test_visibility_and_attributes() {

FILE: benches/basic.rs
  function runtime (line 22) | fn runtime() -> Runtime {
  function test (line 26) | async fn test() {
  function test_baseline (line 50) | async fn test_baseline() {
  function spawn_many (line 71) | async fn spawn_many(size: usize) {
  function spawn_many_baseline (line 87) | async fn spawn_many_baseline(size: usize) {
  function bench_basic (line 103) | fn bench_basic(c: &mut Criterion) {
  function bench_basic_baseline (line 115) | fn bench_basic_baseline(c: &mut Criterion) {
  function bench_many_baseline (line 133) | fn bench_many_baseline(c: &mut Criterion) {
  function bench_many_exp (line 140) | fn bench_many_exp(c: &mut Criterion) {

FILE: examples/basic.rs
  function bar (line 23) | async fn bar(i: i32) {
  function baz (line 28) | async fn baz(i: i32) {
  function foo (line 35) | async fn foo() {
  function main (line 45) | async fn main() {

FILE: examples/detach.rs
  function work (line 25) | async fn work(rx: Receiver<()>) {
  function main (line 49) | async fn main() {

FILE: examples/global.rs
  function bar (line 27) | async fn bar() {
  function foo (line 31) | async fn foo() {
  function print (line 36) | async fn print() {
  function main (line 57) | async fn main() {

FILE: examples/instrument.rs
  function fetch_data (line 22) | async fn fetch_data(id: u32) -> String {
  function process_item (line 28) | async fn process_item(name: &str, value: i32) -> i32 {
  function complex_operation (line 34) | async fn complex_operation() -> Vec<String> {
  function simple_task (line 49) | async fn simple_task() -> String {
  function main (line 55) | async fn main() {

FILE: examples/long_running.rs
  function long_running_child (line 25) | async fn long_running_child() {
  function child (line 31) | async fn child() {
  function foo (line 35) | async fn foo() {
  function work (line 39) | async fn work() -> String {
  function main (line 50) | async fn main() {

FILE: examples/multiple.rs
  function work (line 24) | async fn work(i: i32) {
  function foo (line 28) | async fn foo() {
  function main (line 33) | async fn main() {

FILE: examples/serde.rs
  function work (line 32) | async fn work(rx: Receiver<()>) {
  function main (line 56) | async fn main() {

FILE: examples/spawn.rs
  type Actor (line 30) | struct Actor(usize);
  function actor (line 32) | async fn actor(i: usize) {
  function main (line 44) | async fn main() {

FILE: examples/verbose.rs
  function foo (line 24) | async fn foo() {
  function work (line 29) | async fn work(verbose: bool) -> String {
  function main (line 40) | async fn main() {

FILE: src/context.rs
  type SpanNode (line 27) | struct SpanNode {
    method new (line 37) | fn new(span: Span) -> Self {
  type ContextId (line 53) | pub(crate) struct ContextId(pub(crate) u64);
  type Tree (line 57) | pub struct Tree {
    method fmt (line 146) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method active_node_count (line 201) | pub(crate) fn active_node_count(&self) -> usize {
    method detached_node_count (line 207) | pub(crate) fn detached_node_count(&self) -> usize {
    method detached_roots (line 219) | fn detached_roots(&self) -> impl Iterator<Item = NodeId> + '_ {
    method push (line 230) | pub(crate) fn push(&mut self, span: Span) -> NodeId {
    method step_in (line 242) | pub(crate) fn step_in(&mut self, child: NodeId) {
    method pop (line 256) | pub(crate) fn pop(&mut self) {
    method step_out (line 265) | pub(crate) fn step_out(&mut self) {
    method remove_and_detach (line 276) | pub(crate) fn remove_and_detach(&mut self, node: NodeId) {
    method current (line 283) | pub(crate) fn current(&self) -> NodeId {
  type SpanNodeSer (line 75) | struct SpanNodeSer<'a> {
  method serialize (line 81) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method serialize (line 112) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type TreeContext (line 290) | pub(crate) struct TreeContext {
    method new (line 303) | pub(crate) fn new(root_span: Span, verbose: bool) -> Self {
    method id (line 326) | pub(crate) fn id(&self) -> ContextId {
    method tree (line 331) | pub(crate) fn tree(&self) -> MutexGuard<'_, Tree> {
    method verbose (line 336) | pub(crate) fn verbose(&self) -> bool {
  function current_tree (line 344) | pub fn current_tree() -> Option<Tree> {

FILE: src/future.rs
  type State (line 26) | enum State {
  type Instrumented (line 41) | pub struct Instrumented<F: Future> {
  function new (line 48) | pub(crate) fn new(inner: F, span: Span) -> Self {
  type Output (line 57) | type Output = F::Output;
  method poll (line 59) | fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<S...
  method drop (line 137) | fn drop(self: Pin<&mut Self>) {

FILE: src/global.rs
  function init_global_registry (line 27) | pub fn init_global_registry(config: Config) {
  function global_registry (line 33) | pub(crate) fn global_registry() -> Option<Registry> {

FILE: src/lib.rs
  type InstrumentAwait (line 102) | pub trait InstrumentAwait: Future + Sized {
    method instrument_await (line 104) | fn instrument_await(self, span: impl Into<Span>) -> Instrumented<Self> {

FILE: src/obj_utils.rs
  type DynEq (line 25) | pub(crate) trait DynEq: Any {
    method as_any (line 27) | fn as_any(&self) -> &dyn Any;
    method dyn_eq (line 33) | fn dyn_eq(&self, other: &dyn DynEq) -> bool;
    method as_any (line 40) | fn as_any(&self) -> &dyn Any {
    method dyn_eq (line 44) | fn dyn_eq(&self, other: &dyn DynEq) -> bool {
  type DynHash (line 54) | pub(crate) trait DynHash: DynEq {
    method as_dyn_eq (line 56) | fn as_dyn_eq(&self) -> &dyn DynEq;
    method dyn_hash (line 59) | fn dyn_hash(&self, state: &mut dyn Hasher);
    method as_dyn_eq (line 66) | fn as_dyn_eq(&self) -> &dyn DynEq {
    method dyn_hash (line 70) | fn dyn_hash(&self, mut state: &mut dyn Hasher) {

FILE: src/registry.rs
  type Config (line 32) | pub struct Config {
  method default (line 39) | fn default() -> Self {
  type Key (line 48) | pub trait Key: Hash + Eq + Debug + Send + Sync + 'static {}
  type ObjKey (line 52) | trait ObjKey: DynHash + DynEq + Debug + Send + Sync + 'static {}
  type ToRootSpan (line 57) | pub trait ToRootSpan {
    method to_root_span (line 59) | fn to_root_span(&self) -> Span;
    method to_root_span (line 63) | fn to_root_span(&self) -> Span {
  type AnonymousKey (line 70) | struct AnonymousKey(ContextId);
  method fmt (line 73) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type AnyKey (line 80) | pub struct AnyKey(Arc<dyn ObjKey>);
    method new (line 121) | fn new(key: impl ObjKey) -> Self {
    method as_any (line 126) | pub fn as_any(&self) -> &dyn Any {
    method is (line 133) | pub fn is<K: Any>(&self) -> bool {
    method is_anonymous (line 138) | pub fn is_anonymous(&self) -> bool {
    method downcast_ref (line 145) | pub fn downcast_ref<K: Any>(&self) -> Option<&K> {
  method eq (line 83) | fn eq(&self, other: &Self) -> bool {
  method hash (line 91) | fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
  method fmt (line 97) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method fmt (line 103) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  type Contexts (line 150) | type Contexts = RwLock<WeakValueHashMap<AnyKey, Weak<TreeContext>>>;
  type RegistryCore (line 152) | struct RegistryCore {
  type Registry (line 160) | pub struct Registry(Arc<RegistryCore>);
    method contexts (line 177) | fn contexts(&self) -> &Contexts {
    method config (line 181) | fn config(&self) -> &Config {
    method new (line 188) | pub fn new(config: Config) -> Self {
    method try_current (line 205) | pub fn try_current() -> Option<Self> {
    method current (line 212) | pub fn current() -> Self {
    method register_inner (line 216) | fn register_inner(&self, key: impl Key, context: Arc<TreeContext>) -> ...
    method register (line 232) | pub fn register(&self, key: impl Key, root_span: impl Into<Span>) -> T...
    method register_derived_root (line 241) | pub fn register_derived_root(&self, key: impl Key + ToRootSpan) -> Tre...
    method register_anonymous (line 253) | pub fn register_anonymous(&self, root_span: impl Into<Span>) -> TreeRo...
    method get (line 261) | pub fn get(&self, key: impl Key) -> Option<Tree> {
    method clear (line 269) | pub fn clear(&self) {
    method collect (line 274) | pub fn collect<K: Key + Clone>(&self) -> Vec<(K, Tree)> {
    method collect_anonymous (line 288) | pub fn collect_anonymous(&self) -> Vec<Tree> {
    method collect_all (line 303) | pub fn collect_all(&self) -> Vec<(AnyKey, Tree)> {
  method fmt (line 163) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method clone (line 171) | fn clone(&self) -> Self {
  type WeakRegistry (line 312) | pub(crate) struct WeakRegistry(Weak<RegistryCore>);
    method upgrade (line 315) | pub fn upgrade(&self) -> Option<Registry> {
  function test_registry (line 325) | fn test_registry() {

FILE: src/root.rs
  type TreeRoot (line 24) | pub struct TreeRoot {
    method instrument (line 46) | pub async fn instrument<F: Future>(self, future: F) -> F::Output {
  function current_context (line 33) | pub(crate) fn current_context() -> Option<Arc<TreeContext>> {
  function current_registry (line 37) | pub(crate) fn current_registry() -> Option<Registry> {

FILE: src/span.rs
  type SpanName (line 15) | type SpanName = flexstr::SharedStr;
  function fmt_span (line 18) | pub fn fmt_span(args: std::fmt::Arguments<'_>) -> Span {
  type Span (line 47) | pub struct Span {
    method new (line 54) | fn new(name: SpanName) -> Self {
    method verbose (line 70) | pub fn verbose(mut self) -> Self {
    method long_running (line 82) | pub fn long_running(mut self) -> Self {
    method from (line 107) | fn from(value: S) -> Self {
    method fmt (line 113) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method verbose (line 94) | pub fn verbose(self) -> Span {
  method long_running (line 101) | pub fn long_running(self) -> Span {

FILE: src/spawn.rs
  method spawn (line 29) | pub fn spawn<T>(
  method spawn_derived_root (line 48) | pub fn spawn_derived_root<T>(
  method spawn_anonymous (line 65) | pub fn spawn_anonymous<T>(&self, root_span: impl Into<Span>, future: T) ...
  function spawn (line 80) | pub fn spawn<T>(key: impl Key, root_span: impl Into<Span>, future: T) ->...
  function spawn_derived_root (line 101) | pub fn spawn_derived_root<T>(key: impl Key + ToRootSpan, future: T) -> J...
  function spawn_anonymous (line 116) | pub fn spawn_anonymous<T>(root_span: impl Into<Span>, future: T) -> Join...

FILE: src/tests/functionality.rs
  function sleep (line 22) | async fn sleep(time: u64) {
  function sleep_nested (line 27) | async fn sleep_nested() {
  function multi_sleep (line 35) | async fn multi_sleep() {
  function stream1 (line 43) | fn stream1() -> impl Stream<Item = ()> {
  function stream2 (line 54) | fn stream2() -> impl Stream<Item = ()> {
  function hello (line 74) | async fn hello() {
  function test_await_tree (line 139) | async fn test_await_tree() {

FILE: src/tests/spawn.rs
  function main (line 25) | async fn main() {