icmd 0.1.1

A command-line software 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

use std::{any::TypeId, collections::VecDeque, fmt::Debug, sync::Arc};

use crossterm::event;
use parking_lot::RwLock;

use super::ICmdWindow;

pub trait Sender {
    fn get_window(&self) -> Arc<RwLock<ICmdWindow>>;
    fn send(&self, msg: Message) {
        self.get_window().write().message_queue.push(msg);
    }
}

pub trait Participant: Sender {
    type Params;
    fn resolve(&self, msg: Message, params: Self::Params) -> bool;
    fn get_id(&self) -> TypeId
    where
        Self: Sized + 'static,
    {
        TypeId::of::<Self>()
    }
    fn update(&self, params: Self::Params) -> bool
    where
        Self: Sized + 'static,
    {
        let window = self.get_window();
        let window = window.read();
        let msgs = window.message_queue.peek().cloned();
        drop(window);
        if let Some(msg) = msgs {
            if msg.to == self.get_id() {
                let window = self.get_window();
                let mut window = window.write();
                let message = window.message_queue.pop();
                drop(window);
                if let Some(message) = message {
                    return self.resolve(message, params);
                }
                return true;
            }
            return true;
        } else {
            true
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[allow(dead_code)]
pub enum Content {
    Ready,
    IsReady,
    Update,
    Quit,
    Event(RawEvent),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RawEvent {
    Key(event::KeyCode, event::KeyModifiers),
    Mouse(u16, u16, event::MouseEventKind),
    Update(u64),
}

#[derive(Debug, Clone)]
pub struct Message {
    pub from: TypeId,
    pub to: TypeId,
    pub content: Content,
}

#[derive(Debug)]
pub struct MessageQueue {
    queue: VecDeque<Message>,
    max_len: usize,
}

/// A message queue that allows for sending and receiving messages between participants.
/// It is used to facilitate communication between different components in the system.
/// The queue's length is restricted to a maximum size, and messages are processed in a first-in-first-out (FIFO) manner.
impl MessageQueue {
    /// Creates a new `MessageQueue` with the specified maximum length.
    pub fn new(max_len: usize) -> Self {
        MessageQueue {
            queue: VecDeque::new(),
            max_len,
        }
    }

    /// Pushes a message to the front of the queue.
    pub fn pop(&mut self) -> Option<Message> {
        self.queue.pop_front()
    }

    /// Pushes a message to the back of the queue.
    /// If the queue is full, the oldest message is removed to make space for the new one.
    pub fn push(&mut self, msg: Message) {
        if self.queue.len() >= self.max_len {
            self.queue.pop_back();
        }
        self.queue.push_front(msg);
    }

    /// Peeks at the front of the queue without removing it.
    pub fn peek(&self) -> Option<&Message> {
        self.queue.front()
    }
}