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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::index::list_helpers::dispatch_event;
use crate::index::subobject_helpers::{
    insert_subobject_in_array, remove_subobject_from_parent_array,
};
use crate::index::{Index, IndexEntryProperty};
use crate::HitError;

fn set_object_parent(
    index: &mut Index,
    id: &str,
    new_parent: IndexEntryProperty,
) -> Result<(), HitError> {
    index
        .get_mut(id)
        .ok_or(HitError::IDNotFound(id.to_string(), "set_object_parent".to_string()))?
        .borrow_mut()
        .set_parent(Some(new_parent));
    Ok(())
}

fn check_target_is_not_a_child(index: &Index, id: &str, target_id: &str) -> Result<bool, HitError> {
    let parent = index
        .get(target_id)
        .ok_or(HitError::IDNotFound(target_id.to_string(), "check_target_is_not_a_child".to_string()))?;
    let parent_parent = parent.borrow().get_parent();
    match parent_parent {
        None => Ok(true),
        Some(parent_parent) => {
            if &parent_parent.id == id {
                Ok(false)
            } else {
                return check_target_is_not_a_child(index, id, &parent_parent.id);
            }
        }
    }
}

fn _can_move_object(
    index: &Index,
    id: &str,
    target_parent: IndexEntryProperty,
    _before_id: Option<String>,
) -> Result<(), HitError> {
    //AN OBJECT CANNOT BE ITS OWN PARENT !
    if target_parent.id == id {
        return Err(HitError::CannotBeOwnParent(id.to_string()));
    }

    match index
        .get(id)
        .ok_or(HitError::IDNotFound(id.to_string(), "_can_move_object".to_string()))?
        .borrow()
        .get_parent()
    {
        Some(_) => {}
        None => return Err(HitError::CannotMoveRootObject()),
    }

    //AN OBJECT CANNOT MOVE INSIDE ITSELF
    if !check_target_is_not_a_child(index, id, &target_parent.id)? {
        return Err(HitError::CannotBeOwnChild());
    }
    Ok(())
}

pub fn can_move_object(
    index: &Index,
    id: &str,
    target_parent: IndexEntryProperty,
    before_id: Option<String>,
) -> Result<(), HitError> {
    _can_move_object(index, id, target_parent, before_id)
}

pub fn move_object(
    index: &mut Index,
    id: &str,
    target_parent: IndexEntryProperty,
    before_id: Option<String>,
) -> Result<(), HitError> {
    if Some(id.to_string()) == before_id {
        return Ok(());
    }

    _can_move_object(index, id, target_parent.clone(), before_id.clone())?;

    let original_parent = index
        .get(id)
        .ok_or(HitError::IDNotFound(id.to_string(), "move_object".to_string()))?
        .borrow()
        .get_parent()
        .ok_or(HitError::CannotMoveRootObject())?;
    remove_subobject_from_parent_array(index, id)?;

    set_object_parent(index, id, target_parent.clone())?;

    insert_subobject_in_array(index, target_parent.clone(), id, before_id)?;

    //dispatch event
    dispatch_event(index, &target_parent.id, &target_parent.property)?;
    if target_parent.id != original_parent.id || target_parent.property != original_parent.property
    {
        dispatch_event(index, &original_parent.id, &original_parent.property)?;
    }
    Ok(())
}