Struct Pool 

pub struct Pool {
    pub skipped: Vec<(String, String)>,
    pub missing: RefCell<BTreeSet<String>>,
    pub borrowed: BTreeSet<String>,
    /* private fields */
}

Every schema a package’s profiles may be based on: the package’s own, its dependencies’ and the core release’s.

Fields

skipped: Vec<(String, String)>

Definitions that did not convert, with the reason.

missing: RefCell<BTreeSet<String>>

Bases that were not found (compared over the core type instead).

borrowed: BTreeSet<String>

Bases found only among the other package’s dependencies (see Pool::borrow_bases).

Implementations

impl Pool

pub fn new(loaded: &Loaded) -> Self

Examples found in repository

examples/dump.rs (line 24)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let loaded = load(&args[0]).expect("load");
    let pool = Pool::new(&loaded);
    let profile = pool
        .profiles()
        .into_iter()
        .find(|p| p.url == args[1] || p.name == args[1])
        .expect("profile");
    for path in &args[2..] {
        let parts: Vec<&str> = path.split('.').collect();
        match find(&profile.tree, &parts) {
            Some(n) => println!(
                "{path}: min={} max={:?} types={:?} ms={} slices={:?} children={:?}",
                n.min,
                n.max,
                n.types,
                n.must_support,
                n.slices.keys().collect::<Vec<_>>(),
                n.children.keys().collect::<Vec<_>>()
            ),
            None => println!("{path}: (absent)"),
        }
    }
}

examples/selfcheck.rs (line 24)

fn main() {
    let spec = std::env::args().nth(1).expect("package");
    let loaded = load(&spec).expect("load");
    let pool = Pool::new(&loaded);
    let (mut checked, mut differ) = (0, 0);
    for profile in pool.profiles() {
        let Some(definition) = loaded
            .package
            .definitions
            .iter()
            .find(|d| d.file == profile.file)
        else {
            continue;
        };
        for element in definition.json["snapshot"]["element"]
            .as_array()
            .into_iter()
            .flatten()
        {
            let id = element["id"].as_str().unwrap_or_default();
            let parts: Vec<&str> = id.split('.').skip(1).collect();
            if parts.is_empty() || parts.iter().any(|p| p.contains("[x]:")) {
                continue;
            }
            let Some(node) = find(&profile.tree, &parts) else {
                continue;
            };
            checked += 1;
            let min = element["min"].as_u64().unwrap_or(0) as u32;
            let max = match element["max"].as_str() {
                Some("*") => None,
                Some(m) => m.parse().ok(),
                None => None,
            };
            let ms = element["mustSupport"].as_bool().unwrap_or(false);
            if node.min != min || node.max != max || node.must_support != ms {
                differ += 1;
                if differ <= 25 {
                    println!(
                        "{} {id}: tree {}..{:?} ms={} / snapshot {min}..{max:?} ms={ms}",
                        profile.name, node.min, node.max, node.must_support
                    );
                }
            }
        }
    }
    println!("checked {checked} elements, {differ} differ");
}

pub fn pair(old: &Loaded, new: &Loaded) -> (Self, Self)

The pools of two packages compared with each other, each lent the bases it lacks by the other (Pool::borrow_bases).

pub fn borrow_bases(&mut self, other: &Pool)

Take the bases this package’s profiles need but its manifest does not provide from other, the package compared with. US Core 6.1.0 bases a profile on SDC without listing SDC; comparing that profile over the core type would report SDC’s own constraints as changes. A base with the same canonical URL from the other side’s dependencies isolates the package’s own changes.

pub fn profiles(&self) -> Vec<Profile>

The package’s profiles and extension definitions with their effective trees.

Examples found in repository

examples/dump.rs (line 26)

fn main() {
    let args: Vec<String> = std::env::args().skip(1).collect();
    let loaded = load(&args[0]).expect("load");
    let pool = Pool::new(&loaded);
    let profile = pool
        .profiles()
        .into_iter()
        .find(|p| p.url == args[1] || p.name == args[1])
        .expect("profile");
    for path in &args[2..] {
        let parts: Vec<&str> = path.split('.').collect();
        match find(&profile.tree, &parts) {
            Some(n) => println!(
                "{path}: min={} max={:?} types={:?} ms={} slices={:?} children={:?}",
                n.min,
                n.max,
                n.types,
                n.must_support,
                n.slices.keys().collect::<Vec<_>>(),
                n.children.keys().collect::<Vec<_>>()
            ),
            None => println!("{path}: (absent)"),
        }
    }
}

examples/selfcheck.rs (line 26)

fn main() {
    let spec = std::env::args().nth(1).expect("package");
    let loaded = load(&spec).expect("load");
    let pool = Pool::new(&loaded);
    let (mut checked, mut differ) = (0, 0);
    for profile in pool.profiles() {
        let Some(definition) = loaded
            .package
            .definitions
            .iter()
            .find(|d| d.file == profile.file)
        else {
            continue;
        };
        for element in definition.json["snapshot"]["element"]
            .as_array()
            .into_iter()
            .flatten()
        {
            let id = element["id"].as_str().unwrap_or_default();
            let parts: Vec<&str> = id.split('.').skip(1).collect();
            if parts.is_empty() || parts.iter().any(|p| p.contains("[x]:")) {
                continue;
            }
            let Some(node) = find(&profile.tree, &parts) else {
                continue;
            };
            checked += 1;
            let min = element["min"].as_u64().unwrap_or(0) as u32;
            let max = match element["max"].as_str() {
                Some("*") => None,
                Some(m) => m.parse().ok(),
                None => None,
            };
            let ms = element["mustSupport"].as_bool().unwrap_or(false);
            if node.min != min || node.max != max || node.must_support != ms {
                differ += 1;
                if differ <= 25 {
                    println!(
                        "{} {id}: tree {}..{:?} ms={} / snapshot {min}..{max:?} ms={ms}",
                        profile.name, node.min, node.max, node.must_support
                    );
                }
            }
        }
    }
    println!("checked {checked} elements, {differ} differ");
}

pub fn type_of(&self, url: &str) -> Option<String>

The type a profile constrains (Patient for US Core Patient), or the type itself for a core URL.

pub fn base_node(&self, type_name: &str, child: &str) -> Option<Node>

The core definition of element child of type type_name: what a child that only one version constrains is compared with.

pub fn effective(&self, schema: &FhirSchema) -> Node

schema merged over its base chain, as one tree rooted at the constrained type.