datadog-api-client 0.20.0

Rust client for the Datadog API.
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

// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License.
// This product includes software developed at Datadog (https://www.datadoghq.com/).
// Copyright 2019-Present Datadog, Inc.
use serde::de::{Error, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use serde_with::skip_serializing_none;
use std::fmt::{self, Formatter};

/// Configuration of inline or automatic legends.
#[non_exhaustive]
#[skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SunburstWidgetLegendInlineAutomatic {
    /// Whether to hide the percentages of the groups.
    #[serde(rename = "hide_percent")]
    pub hide_percent: Option<bool>,
    /// Whether to hide the values of the groups.
    #[serde(rename = "hide_value")]
    pub hide_value: Option<bool>,
    /// Whether to show the legend inline or let it be automatically generated.
    #[serde(rename = "type")]
    pub type_: crate::datadogV1::model::SunburstWidgetLegendInlineAutomaticType,
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
    #[serde(skip)]
    #[serde(default)]
    pub(crate) _unparsed: bool,
}

impl SunburstWidgetLegendInlineAutomatic {
    pub fn new(
        type_: crate::datadogV1::model::SunburstWidgetLegendInlineAutomaticType,
    ) -> SunburstWidgetLegendInlineAutomatic {
        SunburstWidgetLegendInlineAutomatic {
            hide_percent: None,
            hide_value: None,
            type_,
            additional_properties: std::collections::BTreeMap::new(),
            _unparsed: false,
        }
    }

    pub fn hide_percent(mut self, value: bool) -> Self {
        self.hide_percent = Some(value);
        self
    }

    pub fn hide_value(mut self, value: bool) -> Self {
        self.hide_value = Some(value);
        self
    }

    pub fn additional_properties(
        mut self,
        value: std::collections::BTreeMap<String, serde_json::Value>,
    ) -> Self {
        self.additional_properties = value;
        self
    }
}

impl<'de> Deserialize<'de> for SunburstWidgetLegendInlineAutomatic {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct SunburstWidgetLegendInlineAutomaticVisitor;
        impl<'a> Visitor<'a> for SunburstWidgetLegendInlineAutomaticVisitor {
            type Value = SunburstWidgetLegendInlineAutomatic;

            fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result {
                f.write_str("a mapping")
            }

            fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
            where
                M: MapAccess<'a>,
            {
                let mut hide_percent: Option<bool> = None;
                let mut hide_value: Option<bool> = None;
                let mut type_: Option<
                    crate::datadogV1::model::SunburstWidgetLegendInlineAutomaticType,
                > = None;
                let mut additional_properties: std::collections::BTreeMap<
                    String,
                    serde_json::Value,
                > = std::collections::BTreeMap::new();
                let mut _unparsed = false;

                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
                    match k.as_str() {
                        "hide_percent" => {
                            if v.is_null() {
                                continue;
                            }
                            hide_percent =
                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "hide_value" => {
                            if v.is_null() {
                                continue;
                            }
                            hide_value = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "type" => {
                            type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                            if let Some(ref _type_) = type_ {
                                match _type_ {
                                    crate::datadogV1::model::SunburstWidgetLegendInlineAutomaticType::UnparsedObject(_type_) => {
                                        _unparsed = true;
                                    },
                                    _ => {}
                                }
                            }
                        }
                        &_ => {
                            if let Ok(value) = serde_json::from_value(v.clone()) {
                                additional_properties.insert(k, value);
                            }
                        }
                    }
                }
                let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;

                let content = SunburstWidgetLegendInlineAutomatic {
                    hide_percent,
                    hide_value,
                    type_,
                    additional_properties,
                    _unparsed,
                };

                Ok(content)
            }
        }

        deserializer.deserialize_any(SunburstWidgetLegendInlineAutomaticVisitor)
    }
}