terminal-chat

1
use std::{collections::{HashMap, VecDeque}, iter};
2

3
#[derive(Debug, Clone)]
4
pub struct PoolMessage {
5
  pub id: String,
6
  pub username: String,
7
  pub message: String,
8
  pub from_server: bool,
9
}
10

11
impl PoolMessage {
12
  fn new() -> PoolMessage {
13
    PoolMessage {
14
      id: String::new(),
15
      username: String::new(),
16
      message: String::new(),
17
      from_server: false,
18
    }
19
  }
20
}
21

22
pub struct MessagesPool {
23
  pool: VecDeque<PoolMessage>,
24
  indexes: HashMap<String, u8>,
25
  length: u16,
26
}
27

28
impl MessagesPool {
29
  pub fn new() -> MessagesPool {
30
    let arr: VecDeque<PoolMessage> = iter::repeat_with(|| PoolMessage::new())
31
      .take(256)
32
      .collect();
33
    MessagesPool { 
34
      pool: arr, 
35
      indexes: HashMap::new(),
36
      length: 0
37
    }
38
  }
39

40
  pub fn push(&mut self, v: PoolMessage) {
41
    if self.length == 256 {
42
      self.pool.pop_front();
43
      self.pool.push_back(v);
44

45
      let mut new_indexes: HashMap<String, u8> = HashMap::new();
46
      for (index, message) in self.pool.iter().enumerate() {
47
        new_indexes.insert(message.id.clone(), index as u8);
48
      }
49
      self.indexes = new_indexes;
50
    }
51
    else {
52
      let index = self.length as u8;
53
      self.pool[index as usize] = v.clone();
54
      self.length += 1;
55
      self.indexes.insert(v.id.clone(), index);
56
    }
57
  }
58

59
  fn read_from(&self, id: &str) -> (Vec<PoolMessage>, Option<String>) {
60
    let found_index = self.indexes.get(id);
61
    match found_index {
62
      Some(v) => {
63
        let index: u16 = v.to_owned() as u16 + 1;
64
        let sliced_pool = &Vec::from(self.pool.clone())[index.into()..self.length.into()];
65
        let sliced_pool_last = {
66
          if sliced_pool.len() == 0 {
67
            None
68
          }
69
          else {
70
            Some(sliced_pool.last().unwrap().clone().id)
71
          }
72
        };
73
        return (sliced_pool.clone().into(), sliced_pool_last)
74
      },
75
      None => {
76
        let last_el = self.last();
77
        let index = match last_el {
78
          Some(v) => Some(v.id.clone()),
79
          None => None
80
        };
81
        let sliced_pool = &Vec::from(self.pool.clone())[..self.length.into()];
82
        return (sliced_pool.into(), index)
83
      }
84
    }
85
  }
86

87
  pub fn has_new(&self, id: &str) -> Option<(Vec<PoolMessage>, Option<String>)> {
88
    let last_el = self.last();
89
    match last_el {
90
      Some(_) => Some(self.read_from(id)),
91
      None => None,
92
    }
93
  }
94

95
  fn last(&self) -> Option<PoolMessage> {
96
    let last_index = {
97
      if self.length > 0 {
98
        self.length - 1
99
      } else {
100
        self.length
101
      }
102
    };
103

104
    let last_el = &self.pool[last_index.into()];
105
    if last_el.id == "".to_owned() {
106
      None
107
    } else {
108
      Some(last_el.to_owned())
109
    }
110
  }
111
}