indi 5.1.1

Client library for interfacing with the Instrument Neutral Distributed Interface (INDI) protocol.
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

use std::{collections::HashMap, ops::Deref};

use crate::{serialization::OneNumber, Number, Parameter};
use twinkle_client::notify::NotifyArc;

use crate::telescope::parameter_with_config::{
    ActiveParameterWithConfig, FromParam, IntoValue, ParameterWithConfig,
};

use super::DeviceError;

#[derive(derive_more::Deref, derive_more::Into, derive_more::From)]
pub struct BinningParameter(ActiveParameterWithConfig<BinningConfig>);

#[derive(Clone, Copy)]
pub struct Binning {
    pub hor: u8,
    pub ver: u8,
}

#[derive(Clone)]
pub struct BinningConfig {
    parameter: &'static str,
    hor: &'static str,
    ver: &'static str,
}

impl BinningConfig {
    pub(super) fn new(parameter: &'static str, hor: &'static str, ver: &'static str) -> Self {
        BinningConfig {
            parameter,
            hor,
            ver,
        }
    }
}

impl IntoValue for BinningConfig {
    type Value = Vec<OneNumber>;
    type SingleValue = Binning;

    fn into_value<T: Into<Self::SingleValue>>(&self, value: T) -> Self::Value {
        let single_value = value.into();
        vec![
            OneNumber {
                name: self.ver.to_string(),
                value: single_value.ver.into(),
            },
            OneNumber {
                name: self.hor.to_string(),
                value: single_value.hor.into(),
            },
        ]
    }
}

impl FromParam for BinningConfig {
    type Value = Binning;
    type Error = DeviceError;

    fn new(param: NotifyArc<Parameter>, config: Self) -> ParameterWithConfig<Self> {
        ParameterWithConfig {
            parameter: param,
            config,
        }
    }
    fn from_parameter<T: Deref<Target = Parameter>>(
        &self,
        param: &T,
    ) -> Result<Self::Value, Self::Error>
    where
        Self: Sized,
    {
        let values = param.deref().get_values::<HashMap<String, Number>>()?;
        let hor: f64 = values
            .get(self.hor)
            .ok_or(DeviceError::Missing)?
            .value
            .into();
        let ver: f64 = values
            .get(self.ver)
            .ok_or(DeviceError::Missing)?
            .value
            .into();
        Ok(Binning {
            hor: hor as u8,
            ver: ver as u8,
        })
    }

    fn get_parameter_name(&self) -> &'static str {
        self.parameter
    }
}