devela/work/sync/
reexports.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
// devela::work::sync::reexports
//
//! Reexported items.
//
// WAIT: [unique_rc_arc](https://github.com/rust-lang/rust/issues/112566)

use crate::reexport;

/* structs */

reexport! { rust: alloc::sync,
    doc: "A thread-safe reference-counting pointer.",
    Arc
}
reexport! { rust: alloc::sync,
    doc: "A version of [`Arc`] that holds a non-owning reference to the managed allocation.",
    @Weak as ArcWeak
}
reexport! { rust: std::sync,
    doc: "Enables multiple threads to synchronize the beginning of some computation.",
    Barrier
}
reexport! { rust: std::sync,
    doc: "Returned by [`Barrier::wait()`] when all threads in the Barrier have rendezvoused.",
    BarrierWaitResult
}
reexport! { rust: std::sync,
    doc: "A Condition Variable",
    Condvar
}
reexport! { rust: std::sync,
    doc: "A mutual exclusion primitive useful for protecting shared data",
    Mutex
}
reexport! { rust: std::sync,
    doc: "An RAII implementation of a “scoped lock” of a mutex.",
    MutexGuard
}
reexport! { rust: std::sync,
    doc: "A synchronization primitive which can be used to run a one-time global initialization.",
    Once
}
reexport! { rust: std::sync,
    doc: "A synchronization primitive which can be written to only once.",
    OnceLock
}
reexport! { rust: std::sync,
    doc: "State yielded to [`Once::call_once_force()`]’s closure parameter.",
    OnceState
}
reexport! { rust: std::sync,
    tag: crate::TAG_ERROR!(),
    doc: "A type of error which can be returned whenever a lock is acquired.",
    PoisonError
}
reexport! { rust: std::sync,
    doc: "A reader-writer lock",
    RwLock
}
reexport! { rust: std::sync,
    doc: "RAII structure used to release the shared read access of a lock when dropped.",
    RwLockReadGuard
}
reexport! { rust: std::sync,
    doc: "RAII structure used to release the exclusive write access of a lock when dropped.",
    RwLockWriteGuard
}
reexport! { rust: std::sync,
    doc: "A type indicating whether a timed wait on a condition variable returned
        due to a time out or not.",
    WaitTimeoutResult
}

/* enums */

reexport! { rust: std::sync,
    tag: crate::TAG_ERROR_COMPOSITE!(),
    doc: "An enumeration of possible errors associated with a [`TryLockResult`].",
    TryLockError
}

/* aliases */

reexport! { rust: std::sync,
    doc: "A type alias for the result of a lock method which can be poisoned.",
    LockResult
}
reexport! { rust: std::sync,
    tag: crate::TAG_RESULT!(),
    doc: "A type alias for the result of a nonblocking locking method.",
    TryLockResult
}