sipp-rs 0.1.0

Unified Rust library for extensible Sipp inference
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

use std::collections::BTreeMap;

use crate::collection::sorted_ref_deltas;
use crate::lifecycle::util::{
    asset_refcount_mismatch, bump_projector_index_revision, decrement_asset_refcount,
    increment_asset_refcount, increment_expected_asset_refcount, manifest_key_mismatch,
    missing_model_asset, model_missing_asset, sorted_model_asset_ids,
    validate_registry_manifest_version,
};
use crate::lifecycle::{ModelEntry, ModelError, RegistryManifest};

/////////////////////////////////////////////////////////////////////////////////
/// TESTS
/////////////////////////////////////////////////////////////////////////////////

#[cfg(test)]
#[path = "../../tests/lifecycle/registry/refs_tests.rs"]
mod refs_tests;

/////////////////////////////////////////////////////////////////////////////////
/// SRC
/////////////////////////////////////////////////////////////////////////////////

pub(super) fn validate_manifest(manifest: &RegistryManifest) -> Result<(), ModelError> {
    validate_registry_manifest_version("manifest", manifest.version)?;
    let mut expected_ref_counts = BTreeMap::<String, u32>::new();
    for (id, asset) in &manifest.assets {
        if id != &asset.id {
            return Err(manifest_key_mismatch("asset", id, &asset.id));
        }
    }
    for (id, model) in &manifest.models {
        if id != &model.id {
            return Err(manifest_key_mismatch("model", id, &model.id));
        }
        for asset_id in referenced_asset_ids(model) {
            if !manifest.assets.contains_key(&asset_id) {
                return Err(model_missing_asset(id, &asset_id));
            }
            increment_expected_asset_refcount(&mut expected_ref_counts, &asset_id)?;
        }
    }
    for (id, asset) in &manifest.assets {
        let expected = expected_ref_counts.get(id).copied().unwrap_or(0);
        if asset.ref_count != expected {
            return Err(asset_refcount_mismatch(id, asset.ref_count, expected));
        }
    }
    Ok(())
}

pub(super) fn referenced_asset_ids(model: &ModelEntry) -> Vec<String> {
    sorted_model_asset_ids(&model.model_asset_ids, model.projector_asset_id.as_ref())
}

pub(super) fn increment_refs(
    manifest: &mut RegistryManifest,
    asset_ids: Vec<String>,
) -> Result<(), ModelError> {
    adjust_refs(manifest, asset_ids, increment_asset_refcount)
}

pub(super) fn rebalance_refs(
    manifest: &mut RegistryManifest,
    previous_refs: &[String],
    updated_refs: &[String],
) -> Result<(), ModelError> {
    let (removed_refs, added_refs) = sorted_ref_deltas(previous_refs, updated_refs);

    if removed_refs.is_empty() && added_refs.is_empty() {
        return Ok(());
    }

    decrement_refs(manifest, removed_refs)?;
    increment_refs(manifest, added_refs)
}

pub(super) fn decrement_refs(
    manifest: &mut RegistryManifest,
    asset_ids: Vec<String>,
) -> Result<(), ModelError> {
    adjust_refs(manifest, asset_ids, decrement_asset_refcount)
}

fn adjust_refs(
    manifest: &mut RegistryManifest,
    asset_ids: Vec<String>,
    adjust_refcount: fn(&mut u32, &str) -> Result<(), ModelError>,
) -> Result<(), ModelError> {
    for id in asset_ids {
        let asset = manifest
            .assets
            .get_mut(&id)
            .ok_or_else(|| missing_model_asset(&id))?;
        adjust_refcount(&mut asset.ref_count, &id)?;
    }
    bump_manifest_projector_index_revision(manifest)?;
    Ok(())
}

fn bump_manifest_projector_index_revision(
    manifest: &mut RegistryManifest,
) -> Result<(), ModelError> {
    bump_projector_index_revision(&mut manifest.projector_index_revision)
}