iscp-rs 1.1.2

iSCPv2 Client 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

use std::time::Duration;

/// アップストリームのフラッシュポリシー
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub enum FlushPolicy {
    None,
    IntervalOnly {
        interval: Duration,
    },
    BufferSizeOnly {
        buffer_size: u64,
    },
    IntervalOrBufferSize {
        interval: Duration,
        buffer_size: u64,
    },
    Immediately,
}

impl Default for FlushPolicy {
    fn default() -> Self {
        Self::IntervalOnly {
            interval: Duration::from_millis(100),
        }
    }
}

impl FlushPolicy {
    pub fn interval(&self) -> Option<Duration> {
        match self {
            Self::IntervalOnly { interval } => Some(*interval),
            Self::IntervalOrBufferSize { interval, .. } => Some(*interval),
            _ => None,
        }
    }

    pub fn buffer_size(&self) -> Option<u64> {
        match self {
            Self::BufferSizeOnly { buffer_size } => Some(*buffer_size),
            Self::IntervalOrBufferSize { buffer_size, .. } => Some(*buffer_size),
            _ => None,
        }
    }

    pub(crate) async fn sleep_by_interval(&self) {
        if let Some(interval) = self.interval() {
            tokio::time::sleep(interval).await;
        } else {
            std::future::pending().await
        }
    }

    pub(crate) fn need_flush(&self, current_buffer_size: usize) -> bool {
        match self {
            Self::Immediately => true,
            Self::BufferSizeOnly { buffer_size } => (*buffer_size as usize) <= current_buffer_size,
            Self::IntervalOrBufferSize { buffer_size, .. } => {
                (*buffer_size as usize) <= current_buffer_size
            }
            _ => false,
        }
    }
}