hit-data 0.0.5

Hierarchical Indexed Typed data structure
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

use std::rc::Rc;

use linked_hash_map::LinkedHashMap;

use crate::{hit_mod::IndexModelImporter, HitError, Hit, HitKernel, Patch, generic_import::finish_import, AddedEntry};

use super::generic_import::import_data_object_values;


pub fn import_from_patches<'a>(
    patches: Vec<Patch>,
    id: &str,
    kernel: Rc<HitKernel>
) -> Result<Hit, HitError> {
    let mut entries = LinkedHashMap::new();
    import_from_patches_and_entries(patches, id, kernel, &mut entries)
}

pub fn import_from_patches_and_entries<'a>(
    patches: Vec<Patch>,
    id: &str,
    kernel: Rc<HitKernel>,
    entries: &mut LinkedHashMap<String, AddedEntry>
) -> Result<Hit, HitError> {
    for patch in patches {
        import_patch(patch, entries)?;
    }

    let mut importer = IndexModelImporter::new(id, kernel.clone());
    for entry in entries.iter() {
        let id = entry.0;
        let added_entry = entry.1;
        let model = {
            kernel
                .get_model(&added_entry.model)?
        };
        import_data_object_values(
            model,
            id.clone(),
            added_entry.parent.clone(),
            &mut importer,
            added_entry.data.clone(),
        )?;
    }

    let hit = finish_import(importer, kernel)?;
    return Ok(hit);
}

pub fn apply_patches(hit: &Hit, patches: Vec<Patch>) -> Result<Hit, HitError> {
    let mut entries = LinkedHashMap::new();
    for entry in hit.index.iter() {
        let model = hit.get_model(&entry.0).unwrap();
        entries.insert(entry.0.to_string(), AddedEntry {
            id: entry.0.clone(),
            data: entry.1.borrow().data.clone(),
            parent: entry.1.borrow().get_parent(),
            model: model.get_name().to_string(),
        });
    }
    import_from_patches_and_entries(patches, hit.get_main_object_id(), hit.kernel.clone(), &mut entries)
}

pub fn duplicate_hit(hit: &Hit) -> Result<Hit, HitError> {
    apply_patches(hit, vec![])
}

fn import_patch<'a>(
    patch: Patch,
    entries: &mut LinkedHashMap<String, AddedEntry>,
) -> Result<(), HitError> {
    for deleted in patch.deleted.iter() {
        entries.remove(deleted);
    }
    for added in patch.added.iter() {
        entries.insert(added.id.clone(), added.clone());
    }
    for changed in patch.differences.iter() {
        let entry = entries.get_mut(&changed.id).unwrap();
        entry.data.remove(&changed.property);
        entry
            .data
            .insert(changed.property.clone(), changed.new_value.clone());
    }
    return Ok(());
}