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

// 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};

/// Datadog product integrations for the datastore entity
#[non_exhaustive]
#[skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct EntityV3QueueDatadog {
    /// Events associations
    #[serde(rename = "events")]
    pub events: Option<Vec<crate::datadogV2::model::EntityV3DatadogEventItem>>,
    /// Logs association
    #[serde(rename = "logs")]
    pub logs: Option<Vec<crate::datadogV2::model::EntityV3DatadogLogItem>>,
    /// Performance stats association
    #[serde(rename = "performanceData")]
    pub performance_data: Option<crate::datadogV2::model::EntityV3DatadogPerformance>,
    #[serde(skip)]
    #[serde(default)]
    pub(crate) _unparsed: bool,
}

impl EntityV3QueueDatadog {
    pub fn new() -> EntityV3QueueDatadog {
        EntityV3QueueDatadog {
            events: None,
            logs: None,
            performance_data: None,
            _unparsed: false,
        }
    }

    pub fn events(mut self, value: Vec<crate::datadogV2::model::EntityV3DatadogEventItem>) -> Self {
        self.events = Some(value);
        self
    }

    pub fn logs(mut self, value: Vec<crate::datadogV2::model::EntityV3DatadogLogItem>) -> Self {
        self.logs = Some(value);
        self
    }

    pub fn performance_data(
        mut self,
        value: crate::datadogV2::model::EntityV3DatadogPerformance,
    ) -> Self {
        self.performance_data = Some(value);
        self
    }
}

impl Default for EntityV3QueueDatadog {
    fn default() -> Self {
        Self::new()
    }
}

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

            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 events: Option<Vec<crate::datadogV2::model::EntityV3DatadogEventItem>> =
                    None;
                let mut logs: Option<Vec<crate::datadogV2::model::EntityV3DatadogLogItem>> = None;
                let mut performance_data: Option<
                    crate::datadogV2::model::EntityV3DatadogPerformance,
                > = None;
                let mut _unparsed = false;

                while let Some((k, v)) = map.next_entry::<String, serde_json::Value>()? {
                    match k.as_str() {
                        "events" => {
                            if v.is_null() {
                                continue;
                            }
                            events = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "logs" => {
                            if v.is_null() {
                                continue;
                            }
                            logs = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        "performanceData" => {
                            if v.is_null() {
                                continue;
                            }
                            performance_data =
                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                        }
                        &_ => {
                            return Err(serde::de::Error::custom(
                                "Additional properties not allowed",
                            ));
                        }
                    }
                }

                let content = EntityV3QueueDatadog {
                    events,
                    logs,
                    performance_data,
                    _unparsed,
                };

                Ok(content)
            }
        }

        deserializer.deserialize_any(EntityV3QueueDatadogVisitor)
    }
}