fui_core 0.18.0

Core library of FUI MVVM UI Framework
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
135
136
137
138
139
140
141
142

use crate::{Event, ObservableCollection, Subscription, VecDiff};
use std::cell::{RefCell, RefMut};
use std::rc::Rc;

///
/// ObservableCollectionMap.
///
pub struct ObservableCollectionMap<TDst: 'static + Clone> {
    items: Rc<RefCell<Vec<TDst>>>,
    changed_event: Rc<RefCell<Event<VecDiff<TDst>>>>,
    _items_changed_event_subscription: Option<Subscription>,
}

impl<T: 'static + Clone> ObservableCollection<T> for ObservableCollectionMap<T> {
    fn len(&self) -> usize {
        self.items.borrow().len()
    }

    fn get(&self, index: usize) -> Option<T> {
        self.items
            .borrow()
            .as_slice()
            .get(index)
            .map(|el| el.clone())
    }

    fn on_changed(&self, f: Box<dyn FnMut(VecDiff<T>)>) -> Option<Subscription> {
        Some(Subscription::EventSubscription(
            self.changed_event.borrow_mut().subscribe(f),
        ))
    }
}

pub trait ObservableCollectionExt<T: 'static + Clone> {
    fn map<TDst, F>(&self, f: F) -> ObservableCollectionMap<TDst>
    where
        TDst: 'static + Clone,
        F: 'static + Fn(&T) -> TDst;
}

impl<T> ObservableCollectionExt<T> for dyn ObservableCollection<T>
where
    T: 'static + Clone,
{
    fn map<TDst, F>(&self, f: F) -> ObservableCollectionMap<TDst>
    where
        TDst: 'static + Clone,
        F: 'static + Fn(&T) -> TDst,
    {
        let items_vec = self.into_iter().map(|item| f(&item)).collect();
        let items_rc = Rc::new(RefCell::new(items_vec));

        let changed_event_rc = Rc::new(RefCell::new(Event::new()));

        let handler = Box::new({
            let items_rc = items_rc.clone();
            let changed_event_rc = changed_event_rc.clone();
            move |changed_args| match changed_args {
                VecDiff::Clear {} => {
                    (items_rc.borrow_mut() as RefMut<'_, Vec<TDst>>).clear();
                    changed_event_rc.borrow().emit(VecDiff::Clear {});
                }

                VecDiff::InsertAt { index, value } => {
                    let mut vec: RefMut<'_, Vec<TDst>> = items_rc.borrow_mut();
                    let new_item = f(&value);
                    let new_item_clone = new_item.clone();
                    vec.insert(index, new_item);

                    changed_event_rc.borrow().emit(VecDiff::InsertAt {
                        index,
                        value: new_item_clone,
                    });
                }

                VecDiff::RemoveAt { index } => {
                    items_rc.borrow_mut().remove(index);
                    changed_event_rc.borrow().emit(VecDiff::RemoveAt { index });
                }

                VecDiff::Move {
                    old_index,
                    new_index,
                } => {
                    let mut vec = items_rc.borrow_mut();
                    let value = vec.remove(old_index);
                    vec.insert(new_index, value.clone());
                    changed_event_rc
                        .borrow()
                        .emit(VecDiff::RemoveAt { index: old_index });
                    changed_event_rc.borrow().emit(VecDiff::InsertAt {
                        index: new_index,
                        value,
                    });
                }

                VecDiff::Pop {} => {
                    items_rc.borrow_mut().pop().unwrap();
                    changed_event_rc.borrow().emit(VecDiff::Pop {});
                }

                VecDiff::Push { value } => {
                    let new_item = f(&value);
                    items_rc.borrow_mut().push(new_item.clone());
                    changed_event_rc
                        .borrow()
                        .emit(VecDiff::Push { value: new_item });
                }
            }
        });
        let event_subscription = self.on_changed(handler);

        ObservableCollectionMap {
            items: items_rc,
            changed_event: changed_event_rc,
            _items_changed_event_subscription: event_subscription,
        }
    }
}

impl<T, TSrcColl> ObservableCollectionExt<T> for TSrcColl
where
    T: 'static + Clone,
    TSrcColl: ObservableCollection<T> + 'static,
    Self: Sized,
{
    /// Map creates new observable collection.
    ///
    /// It keeps mapped copy of every item.
    ///
    /// The only connection between it and original observable collection
    /// is by subscribing on the `on_changed` event of the source collection,
    /// so we don't have to keep implicit reference to the source collection.
    /// The `on_change` event of source collection keeps a weak reference to our handler.
    fn map<TDst, F>(&self, f: F) -> ObservableCollectionMap<TDst>
    where
        TDst: 'static + Clone,
        F: 'static + Fn(&T) -> TDst,
    {
        (self as &dyn ObservableCollection<T>).map(f)
    }
}