bernardo-tui 0.2.7

A keyboard-only, distraction-free TUI widget library
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::marker::PhantomData;
use std::mem;
use std::time::Duration;

use log::{debug, error};

use crate::promise::promise::{Promise, PromiseState, UpdateResult};

pub struct MappedPromise<A, P: Promise<A> + Sized, B, F: FnOnce(A) -> B> {
    // if broken, everything will be set to None
    // if resolved, value will be set to Some
    // if unresolved, value will be None, and parent and mapper are expected to be Some
    parent: Option<P>,
    value: Option<B>,
    mapper: Option<F>,
    _phantom: PhantomData<A>,
}

impl<A, P: Promise<A> + Sized, B, F: FnOnce(A) -> B> MappedPromise<A, P, B, F> {
    pub fn new(parent: P, mapper: F) -> Self {
        MappedPromise {
            parent: Some(parent),
            value: None,
            mapper: Some(mapper),
            _phantom: Default::default(),
        }
    }

    fn break_promise(&mut self) {
        self.parent = None;
        self.mapper = None;
        self.value = None;
    }

    // assumes parent resolved OR broke
    fn execute_mapping(&mut self) -> PromiseState {
        // paranoia asserts

        debug_assert!(self.parent.is_some());
        debug_assert!(self.parent.as_ref().unwrap().state() != PromiseState::Unresolved);
        debug_assert!(self.mapper.is_some());

        if !self.parent.as_ref().map(|p| p.state() != PromiseState::Unresolved).unwrap_or(false) {
            error!("executing mapping on unresolved parent! Breaking promise.");
            self.break_promise();
            return PromiseState::Broken;
        }
        if self.mapper.is_none() {
            self.break_promise();
            return PromiseState::Broken;
        }

        let mut parent = None;
        mem::swap(&mut self.parent, &mut parent);
        let parent = parent.unwrap();

        match parent.state() {
            PromiseState::Unresolved => {
                // this is a paranoid failsafe
                error!("executing mapping on unresolved parent! Breaking promise.");
                self.break_promise();
                PromiseState::Broken
            }
            PromiseState::Ready => {
                let value_op = parent.take();
                debug_assert!(value_op.is_some());
                let value = value_op.unwrap();

                debug_assert!(self.mapper.is_some());
                let mut mapper = None;
                mem::swap(&mut self.mapper, &mut mapper);
                let new_value = (mapper.unwrap())(value);
                self.value = Some(new_value);
                self.parent = None;
                PromiseState::Ready
            }
            PromiseState::Broken => {
                self.break_promise();
                PromiseState::Broken
            }
        }
    }
}

impl<A, P: Promise<A>, B, F: FnOnce(A) -> B> Promise<B> for MappedPromise<A, P, B, F> {
    fn state(&self) -> PromiseState {
        if self.value.is_some() {
            debug_assert!(self.mapper.is_none() && self.parent.is_none(), "failed cleanup on resolve");
            return PromiseState::Ready;
        }

        if self.parent.is_some() {
            debug_assert!(self.value.is_none());
            debug_assert!(self.mapper.is_some());
            return PromiseState::Unresolved;
        }

        debug_assert!(self.mapper.is_none());
        debug_assert!(self.parent.is_none());
        debug_assert!(self.value.is_none());
        PromiseState::Broken
    }

    fn wait(&mut self, how_long: Option<Duration>) -> PromiseState {
        if self.state() == PromiseState::Ready {
            debug!("rather unexpected wait on done");
            return PromiseState::Ready;
        }

        if self.state() == PromiseState::Broken {
            debug!("waiting on broken promise");
            return PromiseState::Broken;
        }

        match self.parent.as_mut().unwrap().wait(how_long) {
            PromiseState::Unresolved => PromiseState::Unresolved,
            _ => self.execute_mapping(),
        }
    }

    fn update(&mut self) -> UpdateResult {
        match self.state() {
            PromiseState::Ready => {
                debug!("rather unexpected update after ready");
                UpdateResult {
                    state: PromiseState::Ready,
                    has_changed: false,
                }
            }
            PromiseState::Broken => {
                debug!("rather unexpected update of broken promise");
                UpdateResult {
                    state: PromiseState::Broken,
                    has_changed: false,
                }
            }
            PromiseState::Unresolved => {
                if self.parent.as_mut().unwrap().update().state.is_resolved() {
                    let state = self.execute_mapping();
                    UpdateResult { state, has_changed: true }
                } else {
                    UpdateResult {
                        state: PromiseState::Unresolved,
                        has_changed: false,
                    }
                }
            }
        }
    }

    fn read(&self) -> Option<&B> {
        self.value.as_ref()
    }

    fn take(self) -> Option<B> {
        self.value
    }
}