sdf-metadata 0.14.0

metadata definition for core sdf
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

use std::collections::BTreeMap;

use anyhow::{anyhow, Context, Result};

use crate::wit::{
    dataflow::PackageImport,
    package_interface::{PackageDefinition, StateTyped},
};

use super::sdf_types_map::SdfTypesMap;

pub fn merge_types_and_states(
    all_types: &mut SdfTypesMap,
    all_states: &mut BTreeMap<String, StateTyped>,
    imports: &[PackageImport],
    package_configs: &[PackageDefinition],
) -> Result<()> {
    for import in imports.iter() {
        let pkg_config = package_configs
            .iter()
            .find(|pkg| import.metadata == pkg.meta)
            .context("package not found")?;

        let pkg_types = pkg_config.types_map();

        for ty in &import.types {
            let imported_ty = pkg_types.get_type_tree(ty);

            for (name, imported_ty) in imported_ty.iter() {
                if let Some(prev) = all_types.insert_imported(name.clone(), imported_ty.clone()) {
                    if &prev.0 != imported_ty {
                        return Err(anyhow!(
                            "imported type {} from {} conflicts with existing type",
                            name,
                            import.metadata.name
                        ));
                    }
                }
            }
        }

        for state in &import.states {
            let state = pkg_config
                .states
                .iter()
                .find(|s| s.name == *state)
                .ok_or_else(|| {
                    anyhow!(
                        "state {} not found in imported package {}",
                        state,
                        import.metadata.name
                    )
                })?;
            let imported_ty = pkg_types.get_type_tree(&state.name);
            for (name, imported_ty) in imported_ty.iter() {
                if let Some(prev) = all_types.insert_imported(name.clone(), imported_ty.clone()) {
                    if &prev.0 != imported_ty {
                        return Err(anyhow!(
                            "imported type {} from {} conflicts with existing type",
                            name,
                            import.metadata.name
                        ));
                    }
                }
            }

            all_states.insert(state.name.clone(), state.clone());
        }
    }

    resolve_states(all_states, all_types)?;

    Ok(())
}

fn resolve_states(states: &mut BTreeMap<String, StateTyped>, types: &SdfTypesMap) -> Result<()> {
    for state in states.values_mut() {
        state.resolve(types)?;
    }

    Ok(())
}