devela 0.29.0

A development substrate of coherence.
Documentation 
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
93
94
95
96
97
98
99
100
101
102

// devela/src/work/sync/_reexport_std.rs
//
//!
//
// WAIT: [unique_rc_arc](https://github.com/rust-lang/rust/issues/112566)

#[allow(unused_imports, reason = "symlinked from devela")]
use crate::{_reexport, _tags};

/* `std` structs */

_reexport! { rust: std::sync,
    location: "work/sync" => struct Barrier, tag: _tags!(concurrency),
    doc: "Enables multiple threads to synchronize the beginning of some computation.",
    Barrier
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct BarrierWaitResult, tag: _tags!(concurrency result),
    doc: "Returned by [`Barrier::wait()`] when all threads in it have rendezvoused.",
    BarrierWaitResult
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct Condvar, tag: _tags!(concurrency),
    doc: "A Condition Variable.",
    Condvar
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct LazyLock, tag: _tags!(concurrency init),
    doc: "A value which is initialized on the first access.",
    LazyLock
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct Mutex, tag: _tags!(concurrency),
    doc: "A mutual exclusion primitive useful for protecting shared data.",
    Mutex
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct MutexGuard, tag: _tags!(concurrency guard),
    doc: "An RAII implementation of a \"scoped lock\" of a mutex.",
    MutexGuard
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct Once, tag: _tags!(concurrency),
    doc: "A synchronization primitive for one-time global initialization.",
    Once
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct OnceLock, tag: _tags!(concurrency),
    doc: "A synchronization primitive which can be written to only once.",
    OnceLock
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct OnceState, tag: _tags!(concurrency),
    doc: "State yielded to [`Once::call_once_force()`]'s closure parameter.",
    OnceState
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct PoisonError, tag: _tags!(concurrency error),
    doc: "A type of error which can be returned whenever a lock is acquired.",
    PoisonError
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct RwLock, tag: _tags!(concurrency),
    doc: "A reader-writer lock",
    RwLock
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct RwLockReadGuard, tag: _tags!(concurrency),
    doc: "RAII structure used to release the shared read access of a lock when dropped.",
    RwLockReadGuard
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct RwLockWriteGuard, tag: _tags!(concurrency),
    doc: "RAII structure used to release the exclusive write access of a lock when dropped.",
    RwLockWriteGuard
}
_reexport! { rust: std::sync,
    location: "work/sync" => struct WaitTimeoutResult, tag: _tags!(concurrency result),
    doc: "Whether a timed wait on a [`Condvar`] returned due to a time out or not.",
    WaitTimeoutResult
}

/* `std` enums */

_reexport! { rust: std::sync,
    location: "work/sync" => enum TryLockError, tag: _tags!(concurrency error_composite),
    doc: "An enumeration of possible errors associated with a [`TryLockResult`].",
    TryLockError
}

/* `std` aliases */

_reexport! { rust: std::sync,
    location: "work/sync" => type LockResult, tag: _tags!(concurrency result),
    doc: "A type alias for the result of a lock method which can be poisoned.",
    LockResult
}
_reexport! { rust: std::sync,
    location: "work/sync" => type TryLockResult, tag: _tags!(concurrency result),
    doc: "A type alias for the result of a nonblocking locking method.",
    TryLockResult
}