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
87
88
89

use crate::index::{Index, IndexEntryProperty};
use crate::object_data::ObjectValue;
use crate::object_data::ObjectValues;
use crate::object_data::Reference;
use crate::HitError;

pub fn index_reference(
    index: &Index,
    reference: &Reference,
    key: &str,
    id: &str,
) -> Result<(), HitError> {
    let entry = index
        .get(&reference.id)
        .ok_or(HitError::InvalidReference(reference.id.to_string()))?;
    entry.borrow_mut().references.push(IndexEntryProperty {
        id: id.to_string(),
        property: key.to_string(),
    });
    Ok(())
}

pub fn index_object_references(
    index: &mut Index,
    values: ObjectValues,
    id: &str,
) -> Result<(), HitError> {
    for (key, value) in values.iter() {
        match value {
            ObjectValue::Reference(reference) => {
                index_reference(index, reference, key, id)?;
            }
            ObjectValue::VecReference(references) => {
                for reference in references.iter() {
                    index_reference(index, reference, key, id)?;
                }
            }
            _ => {}
        }
    }
    Ok(())
}

pub fn unindex_reference(
    index: &mut Index,
    parent: IndexEntryProperty,
    id: &str,
) -> Result<(), HitError> {
    let entry = index.get(id).ok_or(HitError::IDNotFound(id.to_string(), "unindex_reference".to_string()))?;
    entry.borrow_mut().references.retain(|x| x != &parent);
    Ok(())
}
pub fn unindex_reference_from_property(
    index: &mut Index,
    id: &str,
    property: &str,
) -> Result<(), HitError> {
    let value = index.get_value(id, property);
    match value {
        Some(old_value) => match old_value {
            ObjectValue::Reference(old_value) => {
                unindex_reference(
                    index,
                    IndexEntryProperty {
                        property: property.to_string(),
                        id: id.to_string(),
                    },
                    &old_value.id,
                )?;
            }

            ObjectValue::VecReference(old_value) => {
                for val in old_value {
                    unindex_reference(
                        index,
                        IndexEntryProperty {
                            property: property.to_string(),
                            id: id.to_string(),
                        },
                        &val.id,
                    )?;
                }
            }
            _ => {}
        },
        None => {}
    }
    Ok(())
}