beetry-editor-types 0.2.0

Internal beetry crate. For the public API, check the beetry crate.
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

use anyhow::{Result, anyhow};
use derive_more::{Display, From};
use getset::{CopyGetters, MutGetters, Setters};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};

use crate::id::ChannelSpecId;

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ChannelData {
    pub spec_id: ChannelSpecId,
    pub config: ChannelConfig,
}

impl ChannelData {
    pub fn new(spec_id: ChannelSpecId, config: ChannelConfig) -> Self {
        Self { spec_id, config }
    }
}

#[derive(
    Debug, Clone, PartialEq, Serialize, Deserialize, CopyGetters, Setters, MutGetters, JsonSchema,
)]
pub struct ChannelConfig {
    #[getset(get_copy = "pub", set = "pub")]
    capacity: usize, // there might be channels with 0 capacity
    #[getset(get_copy = "pub", get_mut = "pub")]
    count: SenderReceiverCount,
    #[getset(get_copy = "pub", set = "pub")]
    kind: ChannelKind,
}

impl ChannelConfig {
    pub fn new(input: ChannelConfigInput) -> Self {
        Self {
            capacity: input.capacity,
            kind: input.kind,
            count: <_>::default(),
        }
    }
}

impl From<ChannelConfig> for ChannelConfigInput {
    fn from(value: ChannelConfig) -> Self {
        Self {
            capacity: value.capacity(),
            kind: value.kind(),
        }
    }
}

impl From<ChannelConfig> for ChannelConfigUpdate {
    fn from(value: ChannelConfig) -> Self {
        Self {
            capacity: value.capacity(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct ChannelConfigInput {
    pub capacity: usize,
    pub kind: ChannelKind,
}

impl ChannelConfigInput {
    pub fn new(capacity: usize, kind: ChannelKind) -> Self {
        Self { capacity, kind }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
pub struct ChannelConfigUpdate {
    pub capacity: usize,
}

#[derive(Debug, Display, From, Clone, Copy, PartialEq, Serialize, Deserialize, JsonSchema)]
pub enum ChannelKind {
    Tokio(TokioChannelKind),
}

#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
pub enum TokioChannelKind {
    Mpsc,
    Broadcast,
    Watch,
}

/// Represents the current state of connected senders and receivers
/// On channel creation there are no senders and receivers
#[derive(
    Debug, Default, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, CopyGetters, JsonSchema,
)]
#[getset(get_copy = "pub")]
pub struct SenderReceiverCount {
    sender: usize,
    receiver: usize,
}

impl SenderReceiverCount {
    pub fn increase_sender_count(&mut self) {
        self.sender += 1;
    }

    pub fn decrease_sender_count(&mut self) -> Result<()> {
        self.sender = self
            .sender
            .checked_sub(1)
            .ok_or_else(|| anyhow!("cannot decrease sender count below 0"))?;
        Ok(())
    }

    pub fn increase_receiver_count(&mut self) {
        self.receiver += 1;
    }

    pub fn decrease_receiver_count(&mut self) -> Result<()> {
        self.receiver = self
            .receiver
            .checked_sub(1)
            .ok_or_else(|| anyhow!("cannot decrease receiver count below 0"))?;
        Ok(())
    }
}