platform-data 2.0.0

Data types and traits for the LinksPlatform
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

use std::ops::ControlFlow;

/// Represents the control flow of an operation, similar to `ControlFlow`.
///
/// This is a simplified enum that can be used with iterators and callbacks
/// to indicate whether to continue or break early.
#[repr(usize)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Flow {
    Continue,
    Break,
}

impl Flow {
    /// Returns `true` if this is `Flow::Continue`.
    #[must_use]
    pub const fn is_continue(&self) -> bool {
        matches!(self, Self::Continue)
    }

    /// Returns `true` if this is `Flow::Break`.
    #[must_use]
    pub const fn is_break(&self) -> bool {
        matches!(self, Self::Break)
    }

    /// Converts this `Flow` into a `ControlFlow` that can be used with `try_for_each`.
    ///
    /// ```
    /// use platform_data::Flow;
    /// use std::ops::ControlFlow;
    ///
    /// let mut count = 0;
    /// let result = (0..10).try_for_each(|i| {
    ///     count += 1;
    ///     if i == 5 { Flow::Break.into_control_flow() } else { Flow::Continue.into_control_flow() }
    /// });
    /// assert_eq!(count, 6);
    /// ```
    pub const fn into_control_flow(self) -> ControlFlow<()> {
        match self {
            Self::Continue => ControlFlow::Continue(()),
            Self::Break => ControlFlow::Break(()),
        }
    }
}

impl<C, B> From<ControlFlow<C, B>> for Flow {
    fn from(flow: ControlFlow<C, B>) -> Self {
        match flow {
            ControlFlow::Continue(_) => Self::Continue,
            ControlFlow::Break(_) => Self::Break,
        }
    }
}

impl From<Flow> for ControlFlow<()> {
    fn from(flow: Flow) -> Self {
        match flow {
            Flow::Continue => Self::Continue(()),
            Flow::Break => Self::Break(()),
        }
    }
}