haply 1.0.0

Haply Robotics Client Library for the Inverse Service
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Shared enums and constants for device types, modes, and settings.

use serde::de::{self, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use ts_rs::TS;

// Device type constants
pub const DEVICE_TYPE_INVERSE3: &str = "inverse3";
pub const DEVICE_TYPE_INVERSE3X: &str = "inverse3x";
pub const DEVICE_TYPE_MINVERSE: &str = "minverse";
pub const DEVICE_TYPE_WIRELESS_VERSE_GRIP: &str = "wireless_verse_grip";
pub const DEVICE_TYPE_CUSTOM_VERSE_GRIP: &str = "custom_verse_grip";

#[derive(Copy, Clone, Debug, PartialEq, Default, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum DeviceType {
    #[default]
    Inverse3,
    Inverse3x,
    Minverse,
    VerseGrip,
    WirelessVerseGrip,
    CustomVerseGrip,
    Ruko,
    Kingfisher,
}

impl<'de> Deserialize<'de> for DeviceType {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct DeviceTypeVisitor;

        impl<'de> Visitor<'de> for DeviceTypeVisitor {
            type Value = DeviceType;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("a string or an integer representing device type")
            }

            fn visit_str<E>(self, value: &str) -> Result<DeviceType, E>
            where
                E: de::Error,
            {
                match value {
                    "inverse3" => Ok(DeviceType::Inverse3),
                    "inverse3x" => Ok(DeviceType::Inverse3x),
                    "minverse" => Ok(DeviceType::Minverse),
                    "verse_grip" => Ok(DeviceType::VerseGrip),
                    "wireless_verse_grip" => Ok(DeviceType::WirelessVerseGrip),
                    "custom_verse_grip" => Ok(DeviceType::CustomVerseGrip),
                    "ruko" => Ok(DeviceType::Ruko),
                    "kingfisher" => Ok(DeviceType::Kingfisher),
                    _ => Err(E::custom(format!("unknown device type: {}", value))),
                }
            }

            fn visit_u64<E>(self, value: u64) -> Result<DeviceType, E>
            where
                E: de::Error,
            {
                match value {
                    4 => Ok(DeviceType::Inverse3),
                    6 => Ok(DeviceType::Minverse),
                    _ => Err(E::custom(format!("unknown device type code: {}", value))),
                }
            }

            fn visit_i64<E>(self, value: i64) -> Result<DeviceType, E>
            where
                E: de::Error,
            {
                if value < 0 {
                    return Err(E::custom(format!("negative device type code: {}", value)));
                }
                self.visit_u64(value as u64)
            }
        }

        deserializer.deserialize_any(DeviceTypeVisitor)
    }
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum DeviceMode {
    #[default]
    Idle,
    Position,
    Angular,
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum ControlDomain {
    #[default]
    Undefined,
    Cartesian,
    Angular,
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum ControlMode {
    #[default]
    Idle,
    Position,
    Force,
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum Handedness {
    Left,
    #[default]
    Right,
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
pub enum StreamingMode {
    #[default]
    USB,
    Radio,
}

#[derive(Copy, Clone, Debug, PartialEq, Default, Deserialize, Serialize, TS)]
#[serde(rename_all = "snake_case")]
pub enum CoordinateOrigin {
    #[default]
    DeviceBase,
    WorkspaceCenter,
}

/// Controls how duplicate device entries across `wireless_verse_grip` and
/// `custom_verse_grip` are handled when the same `device_id` appears in both.
#[derive(Copy, Clone, Debug, PartialEq, Default)]
pub enum VerseGripDuplicateMode {
    /// Keep `custom_verse_grip` entries, hide wireless duplicates (default).
    #[default]
    PreferCustom,
    /// Keep `wireless_verse_grip` entries, hide custom duplicates.
    PreferWireless,
    /// Keep both -- no deduplication.
    KeepBoth,
}