rvimage 0.8.3

A remote image viewer with a labeling tool
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

use std::time::Instant;

use serde::{Deserialize, Serialize};

use crate::parameters::{ParamMap, ParamVal};

#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct PredictiveLabelingData {
    pub new_param_name_buffer: String,
    pub new_param_val_buffer: ParamVal,
    pub param_buffers: Vec<String>,
    pub parameters: ParamMap,
    pub url: String,
    pub authorization_headers: Option<String>,
    pub timeout_ms: usize,
    #[serde(default)]
    pub timeout_buffer: String,
    #[serde(skip)]
    trigger: Option<(bool, Instant)>,
    #[serde(skip)]
    pub to_be_removed: Option<usize>,
}

impl PredictiveLabelingData {
    pub fn trigger_prediction(&mut self) {
        self.trigger = Some((true, Instant::now()));
    }
    pub fn untrigger(&mut self) {
        self.trigger = self.trigger.map(|(_, t)| (false, t));
    }
    pub fn prediction_start_triggered(&self) -> bool {
        self.trigger.map(|(start_prediction, _)| start_prediction) == Some(true)
    }
    pub fn trigger_time(&self) -> Option<&Instant> {
        self.trigger.as_ref().map(|(_, t)| t)
    }
    pub fn kill_trigger(&mut self) {
        self.trigger = None;
    }
}

impl Default for PredictiveLabelingData {
    fn default() -> Self {
        Self {
            new_param_name_buffer: String::default(),
            new_param_val_buffer: ParamVal::default(),
            param_buffers: Vec::default(),
            parameters: ParamMap::default(),
            url: "http".into(),
            authorization_headers: None,
            timeout_ms: 30000,
            timeout_buffer: "".into(),
            trigger: None,
            to_be_removed: None,
        }
    }
}

impl PartialEq for PredictiveLabelingData {
    fn eq(&self, other: &Self) -> bool {
        self.authorization_headers == other.authorization_headers
            && self.parameters == other.parameters
            && self.url == other.url
            && self.timeout_ms == other.timeout_ms
    }
}