Skip to main content

load

Function load 

Source
pub fn load(spec: &str) -> Result<Loaded, String>
Expand description

Load spec: a folder, or name@version (installed with its dependencies when missing; needs the registry feature).

Examples found in repository?
examples/dump.rs (line 23)
21fn main() {
22    let args: Vec<String> = std::env::args().skip(1).collect();
23    let loaded = load(&args[0]).expect("load");
24    let pool = Pool::new(&loaded);
25    let profile = pool
26        .profiles()
27        .into_iter()
28        .find(|p| p.url == args[1] || p.name == args[1])
29        .expect("profile");
30    for path in &args[2..] {
31        let parts: Vec<&str> = path.split('.').collect();
32        match find(&profile.tree, &parts) {
33            Some(n) => println!(
34                "{path}: min={} max={:?} types={:?} ms={} slices={:?} children={:?}",
35                n.min,
36                n.max,
37                n.types,
38                n.must_support,
39                n.slices.keys().collect::<Vec<_>>(),
40                n.children.keys().collect::<Vec<_>>()
41            ),
42            None => println!("{path}: (absent)"),
43        }
44    }
45}
More examples
Hide additional examples
examples/selfcheck.rs (line 23)
21fn main() {
22    let spec = std::env::args().nth(1).expect("package");
23    let loaded = load(&spec).expect("load");
24    let pool = Pool::new(&loaded);
25    let (mut checked, mut differ) = (0, 0);
26    for profile in pool.profiles() {
27        let Some(definition) = loaded
28            .package
29            .definitions
30            .iter()
31            .find(|d| d.file == profile.file)
32        else {
33            continue;
34        };
35        for element in definition.json["snapshot"]["element"]
36            .as_array()
37            .into_iter()
38            .flatten()
39        {
40            let id = element["id"].as_str().unwrap_or_default();
41            let parts: Vec<&str> = id.split('.').skip(1).collect();
42            if parts.is_empty() || parts.iter().any(|p| p.contains("[x]:")) {
43                continue;
44            }
45            let Some(node) = find(&profile.tree, &parts) else {
46                continue;
47            };
48            checked += 1;
49            let min = element["min"].as_u64().unwrap_or(0) as u32;
50            let max = match element["max"].as_str() {
51                Some("*") => None,
52                Some(m) => m.parse().ok(),
53                None => None,
54            };
55            let ms = element["mustSupport"].as_bool().unwrap_or(false);
56            if node.min != min || node.max != max || node.must_support != ms {
57                differ += 1;
58                if differ <= 25 {
59                    println!(
60                        "{} {id}: tree {}..{:?} ms={} / snapshot {min}..{max:?} ms={ms}",
61                        profile.name, node.min, node.max, node.must_support
62                    );
63                }
64            }
65        }
66    }
67    println!("checked {checked} elements, {differ} differ");
68}