| //! The `select!` macro. |
| |
| /// A helper macro for `select!` to hide the long list of macro patterns from the documentation. |
| /// |
| /// The macro consists of two stages: |
| /// 1. Parsing |
| /// 2. Code generation |
| /// |
| /// The parsing stage consists of these subparts: |
| /// 1. `@list`: Turns a list of tokens into a list of cases. |
| /// 2. `@list_errorN`: Diagnoses the syntax error. |
| /// 3. `@case`: Parses a single case and verifies its argument list. |
| /// |
| /// The codegen stage consists of these subparts: |
| /// 1. `@init`: Attempts to optimize `select!` away and initializes the list of handles. |
| /// 1. `@count`: Counts the listed cases. |
| /// 3. `@add`: Adds send/receive operations to the list of handles and starts selection. |
| /// 4. `@complete`: Completes the selected send/receive operation. |
| /// |
| /// If the parsing stage encounters a syntax error or the codegen stage ends up with too many |
| /// cases to process, the macro fails with a compile-time error. |
| #[doc(hidden)] |
| #[macro_export] |
| macro_rules! crossbeam_channel_internal { |
| // The list is empty. Now check the arguments of each processed case. |
| (@list |
| () |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @case |
| ($($head)*) |
| () |
| () |
| ) |
| }; |
| // If necessary, insert an empty argument list after `default`. |
| (@list |
| (default => $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| (default() => $($tail)*) |
| ($($head)*) |
| ) |
| }; |
| // But print an error if `default` is followed by a `->`. |
| (@list |
| (default -> $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!( |
| "expected `=>` after `default` case, found `->`" |
| ) |
| }; |
| // Print an error if there's an `->` after the argument list in the default case. |
| (@list |
| (default $args:tt -> $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!( |
| "expected `=>` after `default` case, found `->`" |
| ) |
| }; |
| // Print an error if there is a missing result in a recv case. |
| (@list |
| (recv($($args:tt)*) => $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!( |
| "expected `->` after `recv` case, found `=>`" |
| ) |
| }; |
| // Print an error if there is a missing result in a send case. |
| (@list |
| (send($($args:tt)*) => $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!( |
| "expected `->` after `send` operation, found `=>`" |
| ) |
| }; |
| // Make sure the arrow and the result are not repeated. |
| (@list |
| ($case:ident $args:tt -> $res:tt -> $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!("expected `=>`, found `->`") |
| }; |
| // Print an error if there is a semicolon after the block. |
| (@list |
| ($case:ident $args:tt $(-> $res:pat)* => $body:block; $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| compile_error!( |
| "did you mean to put a comma instead of the semicolon after `}`?" |
| ) |
| }; |
| // The first case is separated by a comma. |
| (@list |
| ($case:ident ($($args:tt)*) $(-> $res:pat)* => $body:expr, $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| ($($tail)*) |
| ($($head)* $case ($($args)*) $(-> $res)* => { $body },) |
| ) |
| }; |
| // Don't require a comma after the case if it has a proper block. |
| (@list |
| ($case:ident ($($args:tt)*) $(-> $res:pat)* => $body:block $($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| ($($tail)*) |
| ($($head)* $case ($($args)*) $(-> $res)* => { $body },) |
| ) |
| }; |
| // Only one case remains. |
| (@list |
| ($case:ident ($($args:tt)*) $(-> $res:pat)* => $body:expr $(,)?) |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| () |
| ($($head)* $case ($($args)*) $(-> $res)* => { $body },) |
| ) |
| }; |
| // Diagnose and print an error. |
| (@list |
| ($($tail:tt)*) |
| ($($head:tt)*) |
| ) => { |
| $crate::crossbeam_channel_internal!(@list_error1 $($tail)*) |
| }; |
| // Stage 1: check the case type. |
| (@list_error1 recv $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error2 recv $($tail)*) |
| }; |
| (@list_error1 send $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error2 send $($tail)*) |
| }; |
| (@list_error1 default $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error2 default $($tail)*) |
| }; |
| (@list_error1 $t:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected one of `recv`, `send`, or `default`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error1 $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error2 $($tail)*); |
| }; |
| // Stage 2: check the argument list. |
| (@list_error2 $case:ident) => { |
| compile_error!( |
| concat!( |
| "missing argument list after `", |
| stringify!($case), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error2 $case:ident => $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "missing argument list after `", |
| stringify!($case), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error2 $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error3 $($tail)*) |
| }; |
| // Stage 3: check the `=>` and what comes after it. |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)*) => { |
| compile_error!( |
| concat!( |
| "missing `=>` after `", |
| stringify!($case), |
| "` case", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* =>) => { |
| compile_error!( |
| "expected expression after `=>`" |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $body:expr; $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma instead of the semicolon after `", |
| stringify!($body), |
| "`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => recv($($a:tt)*) $($tail:tt)*) => { |
| compile_error!( |
| "expected an expression after `=>`" |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => send($($a:tt)*) $($tail:tt)*) => { |
| compile_error!( |
| "expected an expression after `=>`" |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => default($($a:tt)*) $($tail:tt)*) => { |
| compile_error!( |
| "expected an expression after `=>`" |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $f:ident($($a:tt)*) $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma after `", |
| stringify!($f), |
| "(", |
| stringify!($($a)*), |
| ")`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $f:ident!($($a:tt)*) $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma after `", |
| stringify!($f), |
| "!(", |
| stringify!($($a)*), |
| ")`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $f:ident![$($a:tt)*] $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma after `", |
| stringify!($f), |
| "![", |
| stringify!($($a)*), |
| "]`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $f:ident!{$($a:tt)*} $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma after `", |
| stringify!($f), |
| "!{", |
| stringify!($($a)*), |
| "}`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $(-> $r:pat)* => $body:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "did you mean to put a comma after `", |
| stringify!($body), |
| "`?", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) -> => $($tail:tt)*) => { |
| compile_error!("missing pattern after `->`") |
| }; |
| (@list_error3 $case:ident($($args:tt)*) $t:tt $(-> $r:pat)* => $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected `->`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 $case:ident($($args:tt)*) -> $t:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected a pattern, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 recv($($args:tt)*) $t:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected `->`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 send($($args:tt)*) $t:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected `->`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 recv $args:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected an argument list after `recv`, found `", |
| stringify!($args), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 send $args:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected an argument list after `send`, found `", |
| stringify!($args), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 default $args:tt $($tail:tt)*) => { |
| compile_error!( |
| concat!( |
| "expected an argument list or `=>` after `default`, found `", |
| stringify!($args), |
| "`", |
| ) |
| ) |
| }; |
| (@list_error3 $($tail:tt)*) => { |
| $crate::crossbeam_channel_internal!(@list_error4 $($tail)*) |
| }; |
| // Stage 4: fail with a generic error message. |
| (@list_error4 $($tail:tt)*) => { |
| compile_error!("invalid syntax") |
| }; |
| |
| // Success! All cases were parsed. |
| (@case |
| () |
| $cases:tt |
| $default:tt |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @init |
| $cases |
| $default |
| ) |
| }; |
| |
| // Check the format of a recv case. |
| (@case |
| (recv($r:expr $(,)?) -> $res:pat => $body:tt, $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @case |
| ($($tail)*) |
| ($($cases)* recv($r) -> $res => $body,) |
| $default |
| ) |
| }; |
| // Print an error if the argument list is invalid. |
| (@case |
| (recv($($args:tt)*) -> $res:pat => $body:tt, $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "invalid argument list in `recv(", |
| stringify!($($args)*), |
| ")`", |
| ) |
| ) |
| }; |
| // Print an error if there is no argument list. |
| (@case |
| (recv $t:tt $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "expected an argument list after `recv`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| |
| // Check the format of a send case. |
| (@case |
| (send($s:expr, $m:expr $(,)?) -> $res:pat => $body:tt, $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @case |
| ($($tail)*) |
| ($($cases)* send($s, $m) -> $res => $body,) |
| $default |
| ) |
| }; |
| // Print an error if the argument list is invalid. |
| (@case |
| (send($($args:tt)*) -> $res:pat => $body:tt, $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "invalid argument list in `send(", |
| stringify!($($args)*), |
| ")`", |
| ) |
| ) |
| }; |
| // Print an error if there is no argument list. |
| (@case |
| (send $t:tt $($tail:tt)*) |
| ($($cases:tt)*) |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "expected an argument list after `send`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| |
| // Check the format of a default case. |
| (@case |
| (default() => $body:tt, $($tail:tt)*) |
| $cases:tt |
| () |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @case |
| ($($tail)*) |
| $cases |
| (default() => $body,) |
| ) |
| }; |
| // Check the format of a default case with timeout. |
| (@case |
| (default($timeout:expr $(,)?) => $body:tt, $($tail:tt)*) |
| $cases:tt |
| () |
| ) => { |
| $crate::crossbeam_channel_internal!( |
| @case |
| ($($tail)*) |
| $cases |
| (default($timeout) => $body,) |
| ) |
| }; |
| // Check for duplicate default cases... |
| (@case |
| (default $($tail:tt)*) |
| $cases:tt |
| ($($def:tt)+) |
| ) => { |
| compile_error!( |
| "there can be only one `default` case in a `select!` block" |
| ) |
| }; |
| // Print an error if the argument list is invalid. |
| (@case |
| (default($($args:tt)*) => $body:tt, $($tail:tt)*) |
| $cases:tt |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "invalid argument list in `default(", |
| stringify!($($args)*), |
| ")`", |
| ) |
| ) |
| }; |
| // Print an error if there is an unexpected token after `default`. |
| (@case |
| (default $t:tt $($tail:tt)*) |
| $cases:tt |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "expected an argument list or `=>` after `default`, found `", |
| stringify!($t), |
| "`", |
| ) |
| ) |
| }; |
| |
| // The case was not consumed, therefore it must be invalid. |
| (@case |
| ($case:ident $($tail:tt)*) |
| $cases:tt |
| $default:tt |
| ) => { |
| compile_error!( |
| concat!( |
| "expected one of `recv`, `send`, or `default`, found `", |
| stringify!($case), |
| "`", |
| ) |
| ) |
| }; |
| |
| // Optimize `select!` into `try_recv()`. |
| (@init |
| (recv($r:expr) -> $res:pat => $recv_body:tt,) |
| (default() => $default_body:tt,) |
| ) => {{ |
| match $r { |
| ref _r => { |
| let _r: &$crate::Receiver<_> = _r; |
| match _r.try_recv() { |
| ::std::result::Result::Err($crate::TryRecvError::Empty) => { |
| $default_body |
| } |
| _res => { |
| let _res = _res.map_err(|_| $crate::RecvError); |
| let $res = _res; |
| $recv_body |
| } |
| } |
| } |
| } |
| }}; |
| // Optimize `select!` into `recv()`. |
| (@init |
| (recv($r:expr) -> $res:pat => $body:tt,) |
| () |
| ) => {{ |
| match $r { |
| ref _r => { |
| let _r: &$crate::Receiver<_> = _r; |
| let _res = _r.recv(); |
| let $res = _res; |
| $body |
| } |
| } |
| }}; |
| // Optimize `select!` into `recv_timeout()`. |
| (@init |
| (recv($r:expr) -> $res:pat => $recv_body:tt,) |
| (default($timeout:expr) => $default_body:tt,) |
| ) => {{ |
| match $r { |
| ref _r => { |
| let _r: &$crate::Receiver<_> = _r; |
| match _r.recv_timeout($timeout) { |
| ::std::result::Result::Err($crate::RecvTimeoutError::Timeout) => { |
| $default_body |
| } |
| _res => { |
| let _res = _res.map_err(|_| $crate::RecvError); |
| let $res = _res; |
| $recv_body |
| } |
| } |
| } |
| } |
| }}; |
| |
| // // Optimize the non-blocking case with two receive operations. |
| // (@init |
| // (recv($r1:expr) -> $res1:pat => $recv_body1:tt,) |
| // (recv($r2:expr) -> $res2:pat => $recv_body2:tt,) |
| // (default() => $default_body:tt,) |
| // ) => {{ |
| // match $r1 { |
| // ref _r1 => { |
| // let _r1: &$crate::Receiver<_> = _r1; |
| // |
| // match $r2 { |
| // ref _r2 => { |
| // let _r2: &$crate::Receiver<_> = _r2; |
| // |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // } |
| // } |
| // }}; |
| // // Optimize the blocking case with two receive operations. |
| // (@init |
| // (recv($r1:expr) -> $res1:pat => $body1:tt,) |
| // (recv($r2:expr) -> $res2:pat => $body2:tt,) |
| // () |
| // ) => {{ |
| // match $r1 { |
| // ref _r1 => { |
| // let _r1: &$crate::Receiver<_> = _r1; |
| // |
| // match $r2 { |
| // ref _r2 => { |
| // let _r2: &$crate::Receiver<_> = _r2; |
| // |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // } |
| // } |
| // }}; |
| // // Optimize the case with two receive operations and a timeout. |
| // (@init |
| // (recv($r1:expr) -> $res1:pat => $recv_body1:tt,) |
| // (recv($r2:expr) -> $res2:pat => $recv_body2:tt,) |
| // (default($timeout:expr) => $default_body:tt,) |
| // ) => {{ |
| // match $r1 { |
| // ref _r1 => { |
| // let _r1: &$crate::Receiver<_> = _r1; |
| // |
| // match $r2 { |
| // ref _r2 => { |
| // let _r2: &$crate::Receiver<_> = _r2; |
| // |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // } |
| // } |
| // }}; |
| |
| // // Optimize `select!` into `try_send()`. |
| // (@init |
| // (send($s:expr, $m:expr) -> $res:pat => $send_body:tt,) |
| // (default() => $default_body:tt,) |
| // ) => {{ |
| // match $s { |
| // ref _s => { |
| // let _s: &$crate::Sender<_> = _s; |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // }}; |
| // // Optimize `select!` into `send()`. |
| // (@init |
| // (send($s:expr, $m:expr) -> $res:pat => $body:tt,) |
| // () |
| // ) => {{ |
| // match $s { |
| // ref _s => { |
| // let _s: &$crate::Sender<_> = _s; |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // }}; |
| // // Optimize `select!` into `send_timeout()`. |
| // (@init |
| // (send($s:expr, $m:expr) -> $res:pat => $body:tt,) |
| // (default($timeout:expr) => $body:tt,) |
| // ) => {{ |
| // match $s { |
| // ref _s => { |
| // let _s: &$crate::Sender<_> = _s; |
| // // TODO(stjepang): Implement this optimization. |
| // } |
| // } |
| // }}; |
| |
| // Create the list of handles and add operations to it. |
| (@init |
| ($($cases:tt)*) |
| $default:tt |
| ) => {{ |
| const _LEN: usize = $crate::crossbeam_channel_internal!(@count ($($cases)*)); |
| let _handle: &$crate::internal::SelectHandle = &$crate::never::<()>(); |
| |
| #[allow(unused_mut)] |
| let mut _sel = [(_handle, 0, ::std::ptr::null()); _LEN]; |
| |
| $crate::crossbeam_channel_internal!( |
| @add |
| _sel |
| ($($cases)*) |
| $default |
| ( |
| (0usize _oper0) |
| (1usize _oper1) |
| (2usize _oper2) |
| (3usize _oper3) |
| (4usize _oper4) |
| (5usize _oper5) |
| (6usize _oper6) |
| (7usize _oper7) |
| (8usize _oper8) |
| (9usize _oper9) |
| (10usize _oper10) |
| (11usize _oper11) |
| (12usize _oper12) |
| (13usize _oper13) |
| (14usize _oper14) |
| (15usize _oper15) |
| (16usize _oper16) |
| (17usize _oper17) |
| (18usize _oper18) |
| (19usize _oper19) |
| (20usize _oper20) |
| (21usize _oper21) |
| (22usize _oper22) |
| (23usize _oper23) |
| (24usize _oper24) |
| (25usize _oper25) |
| (26usize _oper26) |
| (27usize _oper27) |
| (28usize _oper28) |
| (29usize _oper29) |
| (30usize _oper30) |
| (31usize _oper31) |
| ) |
| () |
| ) |
| }}; |
| |
| // Count the listed cases. |
| (@count ()) => { |
| 0 |
| }; |
| (@count ($oper:ident $args:tt -> $res:pat => $body:tt, $($cases:tt)*)) => { |
| 1 + $crate::crossbeam_channel_internal!(@count ($($cases)*)) |
| }; |
| |
| // Run blocking selection. |
| (@add |
| $sel:ident |
| () |
| () |
| $labels:tt |
| $cases:tt |
| ) => {{ |
| let _oper: $crate::SelectedOperation<'_> = { |
| let _oper = $crate::internal::select(&mut $sel); |
| |
| // Erase the lifetime so that `sel` can be dropped early even without NLL. |
| unsafe { ::std::mem::transmute(_oper) } |
| }; |
| |
| $crate::crossbeam_channel_internal! { |
| @complete |
| $sel |
| _oper |
| $cases |
| } |
| }}; |
| // Run non-blocking selection. |
| (@add |
| $sel:ident |
| () |
| (default() => $body:tt,) |
| $labels:tt |
| $cases:tt |
| ) => {{ |
| let _oper: ::std::option::Option<$crate::SelectedOperation<'_>> = { |
| let _oper = $crate::internal::try_select(&mut $sel); |
| |
| // Erase the lifetime so that `sel` can be dropped early even without NLL. |
| unsafe { ::std::mem::transmute(_oper) } |
| }; |
| |
| match _oper { |
| None => { |
| { $sel }; |
| $body |
| } |
| Some(_oper) => { |
| $crate::crossbeam_channel_internal! { |
| @complete |
| $sel |
| _oper |
| $cases |
| } |
| } |
| } |
| }}; |
| // Run selection with a timeout. |
| (@add |
| $sel:ident |
| () |
| (default($timeout:expr) => $body:tt,) |
| $labels:tt |
| $cases:tt |
| ) => {{ |
| let _oper: ::std::option::Option<$crate::SelectedOperation<'_>> = { |
| let _oper = $crate::internal::select_timeout(&mut $sel, $timeout); |
| |
| // Erase the lifetime so that `sel` can be dropped early even without NLL. |
| unsafe { ::std::mem::transmute(_oper) } |
| }; |
| |
| match _oper { |
| ::std::option::Option::None => { |
| { $sel }; |
| $body |
| } |
| ::std::option::Option::Some(_oper) => { |
| $crate::crossbeam_channel_internal! { |
| @complete |
| $sel |
| _oper |
| $cases |
| } |
| } |
| } |
| }}; |
| // Have we used up all labels? |
| (@add |
| $sel:ident |
| $input:tt |
| $default:tt |
| () |
| $cases:tt |
| ) => { |
| compile_error!("too many operations in a `select!` block") |
| }; |
| // Add a receive operation to `sel`. |
| (@add |
| $sel:ident |
| (recv($r:expr) -> $res:pat => $body:tt, $($tail:tt)*) |
| $default:tt |
| (($i:tt $var:ident) $($labels:tt)*) |
| ($($cases:tt)*) |
| ) => {{ |
| match $r { |
| ref _r => { |
| let $var: &$crate::Receiver<_> = unsafe { |
| let _r: &$crate::Receiver<_> = _r; |
| |
| // Erase the lifetime so that `sel` can be dropped early even without NLL. |
| unsafe fn unbind<'a, T>(x: &T) -> &'a T { |
| ::std::mem::transmute(x) |
| } |
| unbind(_r) |
| }; |
| $sel[$i] = ($var, $i, $var as *const $crate::Receiver<_> as *const u8); |
| |
| $crate::crossbeam_channel_internal!( |
| @add |
| $sel |
| ($($tail)*) |
| $default |
| ($($labels)*) |
| ($($cases)* [$i] recv($var) -> $res => $body,) |
| ) |
| } |
| } |
| }}; |
| // Add a send operation to `sel`. |
| (@add |
| $sel:ident |
| (send($s:expr, $m:expr) -> $res:pat => $body:tt, $($tail:tt)*) |
| $default:tt |
| (($i:tt $var:ident) $($labels:tt)*) |
| ($($cases:tt)*) |
| ) => {{ |
| match $s { |
| ref _s => { |
| let $var: &$crate::Sender<_> = unsafe { |
| let _s: &$crate::Sender<_> = _s; |
| |
| // Erase the lifetime so that `sel` can be dropped early even without NLL. |
| unsafe fn unbind<'a, T>(x: &T) -> &'a T { |
| ::std::mem::transmute(x) |
| } |
| unbind(_s) |
| }; |
| $sel[$i] = ($var, $i, $var as *const $crate::Sender<_> as *const u8); |
| |
| $crate::crossbeam_channel_internal!( |
| @add |
| $sel |
| ($($tail)*) |
| $default |
| ($($labels)*) |
| ($($cases)* [$i] send($var, $m) -> $res => $body,) |
| ) |
| } |
| } |
| }}; |
| |
| // Complete a receive operation. |
| (@complete |
| $sel:ident |
| $oper:ident |
| ([$i:tt] recv($r:ident) -> $res:pat => $body:tt, $($tail:tt)*) |
| ) => {{ |
| if $oper.index() == $i { |
| let _res = $oper.recv($r); |
| { $sel }; |
| |
| let $res = _res; |
| $body |
| } else { |
| $crate::crossbeam_channel_internal! { |
| @complete |
| $sel |
| $oper |
| ($($tail)*) |
| } |
| } |
| }}; |
| // Complete a send operation. |
| (@complete |
| $sel:ident |
| $oper:ident |
| ([$i:tt] send($s:ident, $m:expr) -> $res:pat => $body:tt, $($tail:tt)*) |
| ) => {{ |
| if $oper.index() == $i { |
| let _res = $oper.send($s, $m); |
| { $sel }; |
| |
| let $res = _res; |
| $body |
| } else { |
| $crate::crossbeam_channel_internal! { |
| @complete |
| $sel |
| $oper |
| ($($tail)*) |
| } |
| } |
| }}; |
| // Panic if we don't identify the selected case, but this should never happen. |
| (@complete |
| $sel:ident |
| $oper:ident |
| () |
| ) => {{ |
| unreachable!( |
| "internal error in crossbeam-channel: invalid case" |
| ) |
| }}; |
| |
| // Catches a bug within this macro (should not happen). |
| (@$($tokens:tt)*) => { |
| compile_error!( |
| concat!( |
| "internal error in crossbeam-channel: ", |
| stringify!(@$($tokens)*), |
| ) |
| ) |
| }; |
| |
| // The entry points. |
| () => { |
| compile_error!("empty `select!` block") |
| }; |
| ($($case:ident $(($($args:tt)*))* => $body:expr $(,)*)*) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| ($($case $(($($args)*))* => { $body },)*) |
| () |
| ) |
| }; |
| ($($tokens:tt)*) => { |
| $crate::crossbeam_channel_internal!( |
| @list |
| ($($tokens)*) |
| () |
| ) |
| }; |
| } |
| |
| /// Selects from a set of channel operations. |
| /// |
| /// This macro allows you to define a set of channel operations, wait until any one of them becomes |
| /// ready, and finally execute it. If multiple operations are ready at the same time, a random one |
| /// among them is selected. |
| /// |
| /// It is also possible to define a `default` case that gets executed if none of the operations are |
| /// ready, either right away or for a certain duration of time. |
| /// |
| /// An operation is considered to be ready if it doesn't have to block. Note that it is ready even |
| /// when it will simply return an error because the channel is disconnected. |
| /// |
| /// The `select!` macro is a convenience wrapper around [`Select`]. However, it cannot select over a |
| /// dynamically created list of channel operations. |
| /// |
| /// [`Select`]: super::Select |
| /// |
| /// # Examples |
| /// |
| /// Block until a send or a receive operation is selected: |
| /// |
| /// ``` |
| /// use crossbeam_channel::{select, unbounded}; |
| /// |
| /// let (s1, r1) = unbounded(); |
| /// let (s2, r2) = unbounded(); |
| /// s1.send(10).unwrap(); |
| /// |
| /// // Since both operations are initially ready, a random one will be executed. |
| /// select! { |
| /// recv(r1) -> msg => assert_eq!(msg, Ok(10)), |
| /// send(s2, 20) -> res => { |
| /// assert_eq!(res, Ok(())); |
| /// assert_eq!(r2.recv(), Ok(20)); |
| /// } |
| /// } |
| /// ``` |
| /// |
| /// Select from a set of operations without blocking: |
| /// |
| /// ``` |
| /// use std::thread; |
| /// use std::time::Duration; |
| /// use crossbeam_channel::{select, unbounded}; |
| /// |
| /// let (s1, r1) = unbounded(); |
| /// let (s2, r2) = unbounded(); |
| /// |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_secs(1)); |
| /// s1.send(10).unwrap(); |
| /// }); |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_millis(500)); |
| /// s2.send(20).unwrap(); |
| /// }); |
| /// |
| /// // None of the operations are initially ready. |
| /// select! { |
| /// recv(r1) -> msg => panic!(), |
| /// recv(r2) -> msg => panic!(), |
| /// default => println!("not ready"), |
| /// } |
| /// ``` |
| /// |
| /// Select over a set of operations with a timeout: |
| /// |
| /// ``` |
| /// use std::thread; |
| /// use std::time::Duration; |
| /// use crossbeam_channel::{select, unbounded}; |
| /// |
| /// let (s1, r1) = unbounded(); |
| /// let (s2, r2) = unbounded(); |
| /// |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_secs(1)); |
| /// s1.send(10).unwrap(); |
| /// }); |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_millis(500)); |
| /// s2.send(20).unwrap(); |
| /// }); |
| /// |
| /// // None of the two operations will become ready within 100 milliseconds. |
| /// select! { |
| /// recv(r1) -> msg => panic!(), |
| /// recv(r2) -> msg => panic!(), |
| /// default(Duration::from_millis(100)) => println!("timed out"), |
| /// } |
| /// ``` |
| /// |
| /// Optionally add a receive operation to `select!` using [`never`]: |
| /// |
| /// ``` |
| /// use std::thread; |
| /// use std::time::Duration; |
| /// use crossbeam_channel::{select, never, unbounded}; |
| /// |
| /// let (s1, r1) = unbounded(); |
| /// let (s2, r2) = unbounded(); |
| /// |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_secs(1)); |
| /// s1.send(10).unwrap(); |
| /// }); |
| /// thread::spawn(move || { |
| /// thread::sleep(Duration::from_millis(500)); |
| /// s2.send(20).unwrap(); |
| /// }); |
| /// |
| /// // This receiver can be a `Some` or a `None`. |
| /// let r2 = Some(&r2); |
| /// |
| /// // None of the two operations will become ready within 100 milliseconds. |
| /// select! { |
| /// recv(r1) -> msg => panic!(), |
| /// recv(r2.unwrap_or(&never())) -> msg => assert_eq!(msg, Ok(20)), |
| /// } |
| /// ``` |
| /// |
| /// To optionally add a timeout to `select!`, see the [example] for [`never`]. |
| /// |
| /// [`never`]: super::never |
| /// [example]: super::never#examples |
| #[macro_export] |
| macro_rules! select { |
| ($($tokens:tt)*) => { |
| $crate::crossbeam_channel_internal!( |
| $($tokens)* |
| ) |
| }; |
| } |
