chris 0.4.0

ChRIS 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
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

use serde::{Deserialize, Serialize};
use std::fmt::Display;

#[derive(Serialize, Deserialize, Debug, Copy, Clone, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PluginParameterType {
    Boolean,
    Integer,
    Float,
    String,
    Path,
    Unextpath,
}

/// Plugin instance status
#[derive(Serialize, Deserialize, Debug, Copy, Clone, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub enum Status {
    Created,
    Waiting,
    Scheduled,
    Started,
    RegisteringFiles,
    FinishedSuccessfully,
    FinishedWithError,
    Cancelled,
}

impl Status {
    pub fn simplify(self) -> SimplifiedStatus {
        self.into()
    }
}

/// Simplified variants of [Status].
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub enum SimplifiedStatus {
    Waiting,
    Running,
    Success,
    Error,
    Cancelled,
}

impl From<Status> for SimplifiedStatus {
    fn from(value: Status) -> Self {
        match value {
            Status::Created => Self::Waiting,
            Status::Waiting => Self::Waiting,
            Status::Scheduled => Self::Waiting,
            Status::Started => Self::Running,
            Status::RegisteringFiles => Self::Running,
            Status::FinishedSuccessfully => Self::Success,
            Status::FinishedWithError => Self::Error,
            Status::Cancelled => Self::Cancelled,
        }
    }
}

impl PluginParameterType {
    pub fn as_str(&self) -> &'static str {
        match self {
            PluginParameterType::Boolean => "boolean",
            PluginParameterType::Integer => "int",
            PluginParameterType::Float => "float",
            PluginParameterType::String => "string",
            PluginParameterType::Path => "path",
            PluginParameterType::Unextpath => "unextpath",
        }
    }
}

#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(untagged)]
pub enum PluginParameterValue {
    Boolean(bool),
    Integer(i64),
    Float(f64),

    /// Either a `str`, `path`, or `unextpath`
    Stringish(String),
}

impl Display for PluginParameterValue {
    fn fmt(&self, f1: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            PluginParameterValue::Boolean(b) => b.to_string(),
            PluginParameterValue::Integer(n) => n.to_string(),
            PluginParameterValue::Float(f) => f.to_string(),
            PluginParameterValue::Stringish(s) => s.to_string(),
        };
        write!(f1, "{}", s)
    }
}

#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
#[serde(untagged)]
pub enum ParameterValue {
    Bool(bool),
    Int(i64),
    Float(f64),
    Str(String),
}

/// <https://github.com/FNNDSC/CHRIS_docs/blob/master/specs/ChRIS_Plugins.adoc#plugin-type>
#[derive(Deserialize, Debug, Copy, Clone, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum PluginType {
    Fs,
    Ds,
    Ts,
}

#[derive(Deserialize, Debug, Copy, Clone, Eq, PartialEq)]
pub enum PluginParameterAction {
    #[serde(rename = "store")]
    Store,
    #[serde(rename = "store_true")]
    StoreTrue,
    #[serde(rename = "store_false")]
    StoreFalse,
}