snomed-ecl-engine 0.2.0

Compact SNOMED CT ECL engine and RF2 index builder
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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use super::*;
use crate::store::{Description, DescriptionIndex};

pub(super) fn read(
    archive: &mut ZipArchive<BufReader<File>>,
    lookup: &HashMap<u64, u32>,
    edition_date: u32,
) -> Result<Vec<Description>> {
    let resolve = |sctid| {
        lookup
            .get(&sctid)
            .copied()
            .context("Unknown description metadata concept")
    };
    let files: Vec<_> = archive
        .file_names()
        .filter(|n| {
            n.contains("/Snapshot/")
                && n.ends_with(".txt")
                && n.rsplit('/').next().is_some_and(|f| {
                    f.starts_with("sct2_Description_") || f.starts_with("sct2_TextDefinition_")
                })
        })
        .map(str::to_owned)
        .collect();
    let mut descriptions = Vec::new();
    let mut positions = HashMap::new();
    for file in files {
        rows(
            archive,
            &file,
            &[
                "id",
                "effectiveTime",
                "active",
                "moduleId",
                "conceptId",
                "languageCode",
                "typeId",
                "term",
                "caseSignificanceId",
            ],
            |r| {
                let description = id(r[0])?;
                ensure!(
                    positions.insert(description, descriptions.len()).is_none(),
                    "Duplicate description ID in Snapshot"
                );
                let effective_time = date(r[1])?;
                ensure!(
                    effective_time <= edition_date,
                    "Description is newer than edition"
                );
                let language: [u8; 2] = r[5]
                    .as_bytes()
                    .try_into()
                    .context("Expected two-letter RF2 language")?;
                ensure!(
                    language.iter().all(u8::is_ascii_lowercase),
                    "Expected lowercase RF2 language"
                );
                id(r[8])?;
                ensure!(!r[7].is_empty(), "Empty description term");
                descriptions.push(Description {
                    id: description,
                    concept: resolve(id(r[4])?)?,
                    module: resolve(id(r[3])?)?,
                    kind: resolve(id(r[6])?)?,
                    effective_time,
                    active: active(r[2])?,
                    language,
                    term: r[7].to_owned(),
                    dialects: Vec::new(),
                });
                Ok(())
            },
        )?;
    }
    let language_files: Vec<_> = archive
        .file_names()
        .filter(|n| {
            n.contains("/Snapshot/")
                && n.ends_with(".txt")
                && n.rsplit('/')
                    .next()
                    .is_some_and(|f| f.starts_with("der2_cRefset_Language"))
        })
        .map(str::to_owned)
        .collect();
    let mut seen = HashSet::new();
    for file in language_files {
        rows(
            archive,
            &file,
            &[
                "id",
                "effectiveTime",
                "active",
                "moduleId",
                "refsetId",
                "referencedComponentId",
                "acceptabilityId",
            ],
            |r| {
                ensure!(seen.insert(r[0].to_owned()), "Duplicate language member ID");
                ensure!(
                    date(r[1])? <= edition_date,
                    "Language member is newer than edition"
                );
                resolve(id(r[3])?)?;
                let refset = resolve(id(r[4])?)?;
                let acceptability = resolve(id(r[6])?)?;
                let position = *positions
                    .get(&id(r[5])?)
                    .context("Language member references a missing description")?;
                if active(r[2])? {
                    descriptions[position]
                        .dialects
                        .push((refset, acceptability));
                }
                Ok(())
            },
        )?;
    }
    Ok(descriptions)
}

pub(super) fn build(
    archive: &mut ZipArchive<BufReader<File>>,
    lookup: &HashMap<u64, u32>,
    edition_date: u32,
) -> Result<DescriptionIndex> {
    DescriptionIndex::build(lookup.len(), read(archive, lookup, edition_date)?)
}