use serde::de::{Error, MapAccess, Visitor};
use serde::{Deserialize, Deserializer, Serialize};
use serde_with::skip_serializing_none;
use std::fmt::{self, Formatter};
#[non_exhaustive]
#[skip_serializing_none]
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct ObservabilityPipelineSampleProcessor {
#[serde(rename = "id")]
pub id: String,
#[serde(rename = "include")]
pub include: String,
#[serde(rename = "inputs")]
pub inputs: Vec<String>,
#[serde(rename = "percentage")]
pub percentage: Option<f64>,
#[serde(rename = "rate")]
pub rate: Option<i64>,
#[serde(rename = "type")]
pub type_: crate::datadogV2::model::ObservabilityPipelineSampleProcessorType,
#[serde(flatten)]
pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
#[serde(skip)]
#[serde(default)]
pub(crate) _unparsed: bool,
}
impl ObservabilityPipelineSampleProcessor {
pub fn new(
id: String,
include: String,
inputs: Vec<String>,
type_: crate::datadogV2::model::ObservabilityPipelineSampleProcessorType,
) -> ObservabilityPipelineSampleProcessor {
ObservabilityPipelineSampleProcessor {
id,
include,
inputs,
percentage: None,
rate: None,
type_,
additional_properties: std::collections::BTreeMap::new(),
_unparsed: false,
}
}
pub fn percentage(mut self, value: f64) -> Self {
self.percentage = Some(value);
self
}
pub fn rate(mut self, value: i64) -> Self {
self.rate = 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 ObservabilityPipelineSampleProcessor {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
struct ObservabilityPipelineSampleProcessorVisitor;
impl<'a> Visitor<'a> for ObservabilityPipelineSampleProcessorVisitor {
type Value = ObservabilityPipelineSampleProcessor;
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 id: Option<String> = None;
let mut include: Option<String> = None;
let mut inputs: Option<Vec<String>> = None;
let mut percentage: Option<f64> = None;
let mut rate: Option<i64> = None;
let mut type_: Option<
crate::datadogV2::model::ObservabilityPipelineSampleProcessorType,
> = 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() {
"id" => {
id = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"include" => {
include = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"inputs" => {
inputs = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"percentage" => {
if v.is_null() {
continue;
}
percentage = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
}
"rate" => {
if v.is_null() {
continue;
}
rate = 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::datadogV2::model::ObservabilityPipelineSampleProcessorType::UnparsedObject(_type_) => {
_unparsed = true;
},
_ => {}
}
}
}
&_ => {
if let Ok(value) = serde_json::from_value(v.clone()) {
additional_properties.insert(k, value);
}
}
}
}
let id = id.ok_or_else(|| M::Error::missing_field("id"))?;
let include = include.ok_or_else(|| M::Error::missing_field("include"))?;
let inputs = inputs.ok_or_else(|| M::Error::missing_field("inputs"))?;
let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
let content = ObservabilityPipelineSampleProcessor {
id,
include,
inputs,
percentage,
rate,
type_,
additional_properties,
_unparsed,
};
Ok(content)
}
}
deserializer.deserialize_any(ObservabilityPipelineSampleProcessorVisitor)
}
}