latches 0.1.2

A downward counter (CountDownLatch) which can be used to synchronize threads or coordinate tasks
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

use std::{env, ffi, fmt, io, process, string};

struct ReadVersionError(String);

impl fmt::Debug for ReadVersionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("failed to detect rustc version by ")?;
        f.write_str(self.0.as_str())
    }
}

impl From<io::Error> for ReadVersionError {
    fn from(value: io::Error) -> Self {
        Self(format!("command I/O: {}", value))
    }
}

impl From<string::FromUtf8Error> for ReadVersionError {
    fn from(value: string::FromUtf8Error) -> Self {
        Self(format!("decoding command result: {}", value))
    }
}

impl From<String> for ReadVersionError {
    fn from(value: String) -> Self {
        Self(value)
    }
}

impl fmt::Display for ReadVersionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Debug::fmt(&self, f)
    }
}

impl std::error::Error for ReadVersionError {}

fn read_version(rustc: ffi::OsString) -> Result<(u16, u16), ReadVersionError> {
    let process::Output { status, stdout, .. } = process::Command::new(rustc)
        .args(["--version", "--verbose"])
        .output()?;

    if !status.success() {
        return Err(format!("the status of command result: {}", status).into());
    }

    let output = String::from_utf8(stdout)?;
    let mut version = "";

    // Find the release line in the verbose version output.
    for line in output.lines() {
        if let Some(v) = line.strip_prefix("release: ") {
            version = v;
            break;
        }
    }

    if version.is_empty() {
        return Err(format!("finding release line: {}", output).into());
    }

    // build.rs don't need patch version and edition postfix.
    let mut iter = version.splitn(3, '.');

    if let (Some(major), Some(minor)) = (iter.next(), iter.next()) {
        let major = match major.parse() {
            Ok(t) => t,
            Err(e) => return Err(format!("major: {} {}", major, e).into()),
        };
        let minor = match minor.parse() {
            Ok(t) => t,
            Err(e) => return Err(format!("minor: {} {}", minor, e).into()),
        };

        Ok((major, minor))
    } else {
        Err(format!("spliting: {}", version).into())
    }
}

fn main() {
    let rustc = env::var_os("RUSTC").unwrap_or_else(|| "rustc".into());
    let version = match read_version(rustc) {
        Ok(v) => v,
        Err(e) => {
            println!("cargo:warning=latches: {}", e);
            return;
        }
    };

    if version < (1, 63) {
        println!("cargo:rustc-cfg=latches_no_const_sync");
    }
}