rtsc 0.4.5

Real-time Synchronization Components
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
103
104
105
106

#![ doc = include_str!( concat!( env!( "CARGO_MANIFEST_DIR" ), "/", "README.md" ) ) ]
#![deny(missing_docs)]
/// Data buffer
pub mod buf;
/// Cell synchronization
pub mod cell;
/// Sync channel
pub mod channel;
/// Async channel
pub mod channel_async;
/// Data policies
pub mod data_policy;
/// Event map
pub mod event_map;
/// Priority-inverting-safe locking (Linux only)
#[cfg(target_os = "linux")]
pub mod pi;
#[cfg(not(target_os = "linux"))]
/// Priority-inverting-safe locking (Linux only)
pub mod pi {
    /// Re-exports parking_lot_rt Mutex
    pub type Mutex<T> = parking_lot_rt::Mutex<T>;
    /// Re-exports parking_lot_rt Condvar
    pub type Condvar = parking_lot_rt::Condvar;
    /// Re-exports parking_lot_rt RawMutex
    pub type RawMutex = parking_lot_rt::RawMutex;
    /// Re-exports parking_lot_rt MutexGuard
    pub type MutexGuard<'a, T> = parking_lot_rt::MutexGuard<'a, T>;
}
/// Policy-based sync channel
pub mod policy_channel;
/// Policy-based async channel
pub mod policy_channel_async;
#[cfg(not(target_os = "linux"))]
pub use parking_lot_rt as locking;
#[cfg(target_os = "linux")]
pub use pi as locking;
/// Semaphore
pub mod semaphore;
/// System tools
pub mod system;
/// Time tools
pub mod time;
/// Timestamps
pub use bma_ts;
/// Base channel type, allows to build sync channels with a custom storage
pub mod base_channel;
/// Base async channel type, allows to build async channels with a custom storage
pub mod base_channel_async;
/// Conditional traits
pub mod condvar_api;
/// Time-limited operations
pub mod ops;
/// Policy-based deque
pub mod pdeque;
/// Thread scheduling
pub mod thread_rt;

pub use base_channel::DataChannel;

pub use rtsc_derive::DataPolicy;

/// Error type
#[derive(thiserror::Error, Debug)]
pub enum Error {
    /// the channel is full and the value can not be sent
    #[error("channel full")]
    ChannelFull,
    /// the channel is full, an optional value is skipped. the error can be ignored but should be
    /// logged
    #[error("channel message skipped")]
    ChannelSkipped,
    /// Channel/cell is closed
    #[error("channel closed")]
    ChannelClosed,
    /// Channel/cell is empty
    #[error("channel closed")]
    ChannelEmpty,
    /// The requested operation is not implemented
    #[error("not implemented")]
    Unimplemented,
    /// Timeouts
    #[error("timed out")]
    Timeout,
    /// Invalid data receied / parameters provided
    #[error("Invalid data")]
    InvalidData(String),
    /// All other errors
    #[error("operation failed: {0}")]
    Failed(String),
    /// System call or internal API access denied
    #[error("access denied")]
    AccessDenied,
    /// I/O errors
    #[error("I/O error: {0}")]
    IO(#[from] std::io::Error),
    /// CPU affinity set error
    #[error("CPU affinity set error: {0}")]
    RTSchedSetAffinity(String),
    /// Real-time priority set error
    #[error("Real-time priority set error: {0}")]
    RTSchedSetScheduler(String),
}

/// Result type
pub type Result<T> = std::result::Result<T, Error>;