lcode 0.10.0

An application of terminal write leetcode.一个终端刷力扣的应用
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

use leetcode_api::entities::topic_tags;
use ratatui::widgets::ListState;

#[derive(Clone)]
#[derive(Debug)]
#[derive(Default)]
pub struct TopicsState {
    pub topic_tags: Box<[topic_tags::Model]>,
    pub topic_tags_state: ListState,

    pub user_topic_tags: Vec<String>,
    pub user_topic_tags_translated: Vec<String>,
    pub user_topic_tags_state: ListState,
}

impl TopicsState {
    /// if remove a topic return `true` or `false`
    pub fn rm_user_topic(&mut self) -> bool {
        let mut trigger = false;
        let cur_top = self
            .user_topic_tags_state
            .selected()
            .unwrap_or_default();

        if !self.user_topic_tags.is_empty() {
            self.user_topic_tags.remove(cur_top);
            self.user_topic_tags_translated
                .remove(cur_top);
            trigger = true;
        }
        if cur_top >= self.user_topic_tags.len() {
            self.prev_user();
        }
        trigger
    }
    /// if add a topic return `true` or `false`
    pub fn add_user_topic(&mut self) -> bool {
        let mut trigger = false;
        let cur_top = self
            .topic_tags_state
            .selected()
            .unwrap_or_default();

        let (topic_slug, translated_slug) = self
            .topic_tags
            .get(cur_top)
            .map(|v| {
                (
                    v.topic_slug.clone(),
                    v.name_translated
                        .clone()
                        .unwrap_or_default(),
                )
            })
            .unwrap_or_default();

        if !self
            .user_topic_tags
            .contains(&topic_slug)
        {
            self.user_topic_tags_translated.push(
                if translated_slug.is_empty() {
                    topic_slug.clone()
                }
                else {
                    translated_slug
                },
            );
            self.user_topic_tags.push(topic_slug);
            trigger = true;
        }
        trigger
    }
}

impl TopicsState {
    pub fn prev_user(&mut self) {
        let index = self
            .user_topic_tags_state
            .selected()
            .map_or(0, |i| i.saturating_sub(1));
        self.user_topic_tags_state
            .select(Some(index));
    }
    pub fn next_user(&mut self) {
        let index = self
            .user_topic_tags_state
            .selected()
            .map_or(0, |i| {
                i.saturating_add(1).min(
                    self.user_topic_tags
                        .len()
                        .saturating_sub(1),
                )
            });
        self.user_topic_tags_state
            .select(Some(index));
    }
    pub fn last_user(&mut self) {
        self.user_topic_tags_state
            .select(Some(self.user_topic_tags.len() - 1));
    }
    pub fn first_user(&mut self) {
        self.user_topic_tags_state
            .select(Some(0));
    }
}

impl TopicsState {
    pub fn new(topic_tags: Box<[topic_tags::Model]>) -> Self {
        Self {
            topic_tags,
            topic_tags_state: ListState::default(),

            user_topic_tags: vec![],
            user_topic_tags_translated: vec![],
            user_topic_tags_state: ListState::default(),
        }
    }
    pub fn first(&mut self) {
        self.topic_tags_state.select(Some(0));
    }
    pub fn last(&mut self) {
        self.topic_tags_state
            .select(Some(self.topic_tags.len() - 1));
    }
    pub fn next(&mut self) {
        let i = self
            .topic_tags_state
            .selected()
            .map_or(0, |i| {
                i.saturating_add(1)
                    .min(self.topic_tags.len().saturating_sub(1))
            });
        self.topic_tags_state.select(Some(i));
    }
    pub fn prev(&mut self) {
        let i = self
            .topic_tags_state
            .selected()
            .map_or(0, |i| i.saturating_sub(1));
        self.topic_tags_state.select(Some(i));
    }
}