impl serde::Serialize for BitFieldElementValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BitFieldElementValues", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BitFieldElementValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BitFieldElementValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BitFieldElementValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BitFieldElementValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(BitFieldElementValues {
name: name__.unwrap_or_default(),
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BitFieldElementValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BitFieldValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BitFieldValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BitFieldValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BitFieldValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BitFieldValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BitFieldValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(BitFieldValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BitFieldValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BitFieldValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BitFieldValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BitFieldValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BitFieldValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BitFieldValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BitFieldValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(BitFieldValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BitFieldValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BoolValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BoolValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BoolValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BoolValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BoolValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BoolValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ = Some(map_.next_value()?);
}
}
}
Ok(BoolValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BoolValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BoolValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BoolValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BoolValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BoolValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BoolValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BoolValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(BoolValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BoolValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BytesValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if !self.value.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BytesValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if !self.value.is_empty() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BytesValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BytesValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BytesValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BytesValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
}
}
Ok(BytesValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BytesValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for BytesValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.BytesValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for BytesValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = BytesValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.BytesValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<BytesValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(BytesValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.BytesValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CalculatedChannelQuery {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.channel_key.is_empty() {
len += 1;
}
if self.expression.is_some() {
len += 1;
}
if self.run_id.is_some() {
len += 1;
}
if self.mode.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.CalculatedChannelQuery", len)?;
if !self.channel_key.is_empty() {
struct_ser.serialize_field("channelKey", &self.channel_key)?;
}
if let Some(v) = self.expression.as_ref() {
struct_ser.serialize_field("expression", v)?;
}
if let Some(v) = self.run_id.as_ref() {
struct_ser.serialize_field("runId", v)?;
}
if let Some(v) = self.mode.as_ref() {
let v = super::super::calculated_channels::v1::ExpressionMode::try_from(*v)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
struct_ser.serialize_field("mode", &v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CalculatedChannelQuery {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"channel_key",
"channelKey",
"expression",
"run_id",
"runId",
"mode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ChannelKey,
Expression,
RunId,
Mode,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"channelKey" | "channel_key" => Ok(GeneratedField::ChannelKey),
"expression" => Ok(GeneratedField::Expression),
"runId" | "run_id" => Ok(GeneratedField::RunId),
"mode" => Ok(GeneratedField::Mode),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CalculatedChannelQuery;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.CalculatedChannelQuery")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CalculatedChannelQuery, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut channel_key__ = None;
let mut expression__ = None;
let mut run_id__ = None;
let mut mode__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ChannelKey => {
if channel_key__.is_some() {
return Err(serde::de::Error::duplicate_field("channelKey"));
}
channel_key__ = Some(map_.next_value()?);
}
GeneratedField::Expression => {
if expression__.is_some() {
return Err(serde::de::Error::duplicate_field("expression"));
}
expression__ = map_.next_value()?;
}
GeneratedField::RunId => {
if run_id__.is_some() {
return Err(serde::de::Error::duplicate_field("runId"));
}
run_id__ = map_.next_value()?;
}
GeneratedField::Mode => {
if mode__.is_some() {
return Err(serde::de::Error::duplicate_field("mode"));
}
mode__ = map_.next_value::<::std::option::Option<super::super::calculated_channels::v1::ExpressionMode>>()?.map(|x| x as i32);
}
}
}
Ok(CalculatedChannelQuery {
channel_key: channel_key__.unwrap_or_default(),
expression: expression__,
run_id: run_id__,
mode: mode__,
})
}
}
deserializer.deserialize_struct("sift.data.v1.CalculatedChannelQuery", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ChannelQuery {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.channel_id.is_empty() {
len += 1;
}
if self.run_id.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.ChannelQuery", len)?;
if !self.channel_id.is_empty() {
struct_ser.serialize_field("channelId", &self.channel_id)?;
}
if let Some(v) = self.run_id.as_ref() {
struct_ser.serialize_field("runId", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ChannelQuery {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"channel_id",
"channelId",
"run_id",
"runId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ChannelId,
RunId,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
"runId" | "run_id" => Ok(GeneratedField::RunId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ChannelQuery;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.ChannelQuery")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelQuery, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut channel_id__ = None;
let mut run_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ChannelId => {
if channel_id__.is_some() {
return Err(serde::de::Error::duplicate_field("channelId"));
}
channel_id__ = Some(map_.next_value()?);
}
GeneratedField::RunId => {
if run_id__.is_some() {
return Err(serde::de::Error::duplicate_field("runId"));
}
run_id__ = map_.next_value()?;
}
}
}
Ok(ChannelQuery {
channel_id: channel_id__.unwrap_or_default(),
run_id: run_id__,
})
}
}
deserializer.deserialize_struct("sift.data.v1.ChannelQuery", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DoubleValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0. {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.DoubleValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0. {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DoubleValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DoubleValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.DoubleValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DoubleValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(DoubleValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.DoubleValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DoubleValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.DoubleValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DoubleValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DoubleValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.DoubleValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DoubleValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(DoubleValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.DoubleValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for EnumValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.EnumValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for EnumValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = EnumValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.EnumValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<EnumValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(EnumValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.EnumValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for EnumValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.EnumValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for EnumValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = EnumValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.EnumValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<EnumValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(EnumValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.EnumValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FloatValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0. {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.FloatValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0. {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FloatValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FloatValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.FloatValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FloatValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(FloatValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.FloatValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for FloatValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.FloatValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for FloatValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = FloatValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.FloatValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<FloatValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(FloatValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.FloatValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetDataRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.queries.is_empty() {
len += 1;
}
if self.start_time.is_some() {
len += 1;
}
if self.end_time.is_some() {
len += 1;
}
if self.sample_ms != 0 {
len += 1;
}
if self.page_size != 0 {
len += 1;
}
if !self.page_token.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.GetDataRequest", len)?;
if !self.queries.is_empty() {
struct_ser.serialize_field("queries", &self.queries)?;
}
if let Some(v) = self.start_time.as_ref() {
struct_ser.serialize_field("startTime", v)?;
}
if let Some(v) = self.end_time.as_ref() {
struct_ser.serialize_field("endTime", v)?;
}
if self.sample_ms != 0 {
struct_ser.serialize_field("sampleMs", &self.sample_ms)?;
}
if self.page_size != 0 {
struct_ser.serialize_field("pageSize", &self.page_size)?;
}
if !self.page_token.is_empty() {
struct_ser.serialize_field("pageToken", &self.page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetDataRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"queries",
"start_time",
"startTime",
"end_time",
"endTime",
"sample_ms",
"sampleMs",
"page_size",
"pageSize",
"page_token",
"pageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Queries,
StartTime,
EndTime,
SampleMs,
PageSize,
PageToken,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"queries" => Ok(GeneratedField::Queries),
"startTime" | "start_time" => Ok(GeneratedField::StartTime),
"endTime" | "end_time" => Ok(GeneratedField::EndTime),
"sampleMs" | "sample_ms" => Ok(GeneratedField::SampleMs),
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetDataRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.GetDataRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut queries__ = None;
let mut start_time__ = None;
let mut end_time__ = None;
let mut sample_ms__ = None;
let mut page_size__ = None;
let mut page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Queries => {
if queries__.is_some() {
return Err(serde::de::Error::duplicate_field("queries"));
}
queries__ = Some(map_.next_value()?);
}
GeneratedField::StartTime => {
if start_time__.is_some() {
return Err(serde::de::Error::duplicate_field("startTime"));
}
start_time__ = map_.next_value()?;
}
GeneratedField::EndTime => {
if end_time__.is_some() {
return Err(serde::de::Error::duplicate_field("endTime"));
}
end_time__ = map_.next_value()?;
}
GeneratedField::SampleMs => {
if sample_ms__.is_some() {
return Err(serde::de::Error::duplicate_field("sampleMs"));
}
sample_ms__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::PageSize => {
if page_size__.is_some() {
return Err(serde::de::Error::duplicate_field("pageSize"));
}
page_size__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = Some(map_.next_value()?);
}
}
}
Ok(GetDataRequest {
queries: queries__.unwrap_or_default(),
start_time: start_time__,
end_time: end_time__,
sample_ms: sample_ms__.unwrap_or_default(),
page_size: page_size__.unwrap_or_default(),
page_token: page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.GetDataRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetDataResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.next_page_token.is_empty() {
len += 1;
}
if !self.data.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.GetDataResponse", len)?;
if !self.next_page_token.is_empty() {
struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
}
if !self.data.is_empty() {
struct_ser.serialize_field("data", &self.data)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetDataResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"next_page_token",
"nextPageToken",
"data",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
NextPageToken,
Data,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
"data" => Ok(GeneratedField::Data),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetDataResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.GetDataResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetDataResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut next_page_token__ = None;
let mut data__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = Some(map_.next_value()?);
}
GeneratedField::Data => {
if data__.is_some() {
return Err(serde::de::Error::duplicate_field("data"));
}
data__ = Some(map_.next_value()?);
}
}
}
Ok(GetDataResponse {
next_page_token: next_page_token__.unwrap_or_default(),
data: data__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.GetDataResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Int32Value {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Int32Value", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Int32Value {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Int32Value;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Int32Value")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Int32Value, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(Int32Value {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Int32Value", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Int32Values {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Int32Values", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Int32Values {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Int32Values;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Int32Values")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Int32Values, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(Int32Values {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Int32Values", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Int64Value {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Int64Value", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("value", ToString::to_string(&self.value).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Int64Value {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Int64Value;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Int64Value")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Int64Value, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(Int64Value {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Int64Value", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Int64Values {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Int64Values", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Int64Values {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Int64Values;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Int64Values")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Int64Values, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(Int64Values {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Int64Values", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Metadata {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.data_type != 0 {
len += 1;
}
if self.sampled_ms != 0 {
len += 1;
}
if self.asset.is_some() {
len += 1;
}
if self.run.is_some() {
len += 1;
}
if self.channel.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Metadata", len)?;
if self.data_type != 0 {
let v = super::super::common::r#type::v1::ChannelDataType::try_from(self.data_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.data_type)))?;
struct_ser.serialize_field("dataType", &v)?;
}
if self.sampled_ms != 0 {
struct_ser.serialize_field("sampledMs", &self.sampled_ms)?;
}
if let Some(v) = self.asset.as_ref() {
struct_ser.serialize_field("asset", v)?;
}
if let Some(v) = self.run.as_ref() {
struct_ser.serialize_field("run", v)?;
}
if let Some(v) = self.channel.as_ref() {
struct_ser.serialize_field("channel", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Metadata {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"data_type",
"dataType",
"sampled_ms",
"sampledMs",
"asset",
"run",
"channel",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
DataType,
SampledMs,
Asset,
Run,
Channel,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"dataType" | "data_type" => Ok(GeneratedField::DataType),
"sampledMs" | "sampled_ms" => Ok(GeneratedField::SampledMs),
"asset" => Ok(GeneratedField::Asset),
"run" => Ok(GeneratedField::Run),
"channel" => Ok(GeneratedField::Channel),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Metadata;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Metadata")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Metadata, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut data_type__ = None;
let mut sampled_ms__ = None;
let mut asset__ = None;
let mut run__ = None;
let mut channel__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::DataType => {
if data_type__.is_some() {
return Err(serde::de::Error::duplicate_field("dataType"));
}
data_type__ = Some(map_.next_value::<super::super::common::r#type::v1::ChannelDataType>()? as i32);
}
GeneratedField::SampledMs => {
if sampled_ms__.is_some() {
return Err(serde::de::Error::duplicate_field("sampledMs"));
}
sampled_ms__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
GeneratedField::Asset => {
if asset__.is_some() {
return Err(serde::de::Error::duplicate_field("asset"));
}
asset__ = map_.next_value()?;
}
GeneratedField::Run => {
if run__.is_some() {
return Err(serde::de::Error::duplicate_field("run"));
}
run__ = map_.next_value()?;
}
GeneratedField::Channel => {
if channel__.is_some() {
return Err(serde::de::Error::duplicate_field("channel"));
}
channel__ = map_.next_value()?;
}
}
}
Ok(Metadata {
data_type: data_type__.unwrap_or_default(),
sampled_ms: sampled_ms__.unwrap_or_default(),
asset: asset__,
run: run__,
channel: channel__,
})
}
}
deserializer.deserialize_struct("sift.data.v1.Metadata", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for metadata::Asset {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.asset_id.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Metadata.Asset", len)?;
if !self.asset_id.is_empty() {
struct_ser.serialize_field("assetId", &self.asset_id)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for metadata::Asset {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"asset_id",
"assetId",
"name",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
AssetId,
Name,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"assetId" | "asset_id" => Ok(GeneratedField::AssetId),
"name" => Ok(GeneratedField::Name),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = metadata::Asset;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Metadata.Asset")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<metadata::Asset, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut asset_id__ = None;
let mut name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::AssetId => {
if asset_id__.is_some() {
return Err(serde::de::Error::duplicate_field("assetId"));
}
asset_id__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
}
}
Ok(metadata::Asset {
asset_id: asset_id__.unwrap_or_default(),
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Metadata.Asset", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for metadata::Channel {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.channel_id.is_empty() {
len += 1;
}
if !self.component.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
if self.unit.is_some() {
len += 1;
}
if !self.enum_types.is_empty() {
len += 1;
}
if !self.bit_field_elements.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Metadata.Channel", len)?;
if !self.channel_id.is_empty() {
struct_ser.serialize_field("channelId", &self.channel_id)?;
}
if !self.component.is_empty() {
struct_ser.serialize_field("component", &self.component)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.unit.as_ref() {
struct_ser.serialize_field("unit", v)?;
}
if !self.enum_types.is_empty() {
struct_ser.serialize_field("enumTypes", &self.enum_types)?;
}
if !self.bit_field_elements.is_empty() {
struct_ser.serialize_field("bitFieldElements", &self.bit_field_elements)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for metadata::Channel {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"channel_id",
"channelId",
"component",
"name",
"unit",
"enum_types",
"enumTypes",
"bit_field_elements",
"bitFieldElements",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ChannelId,
Component,
Name,
Unit,
EnumTypes,
BitFieldElements,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
"component" => Ok(GeneratedField::Component),
"name" => Ok(GeneratedField::Name),
"unit" => Ok(GeneratedField::Unit),
"enumTypes" | "enum_types" => Ok(GeneratedField::EnumTypes),
"bitFieldElements" | "bit_field_elements" => Ok(GeneratedField::BitFieldElements),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = metadata::Channel;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Metadata.Channel")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<metadata::Channel, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut channel_id__ = None;
let mut component__ = None;
let mut name__ = None;
let mut unit__ = None;
let mut enum_types__ = None;
let mut bit_field_elements__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ChannelId => {
if channel_id__.is_some() {
return Err(serde::de::Error::duplicate_field("channelId"));
}
channel_id__ = Some(map_.next_value()?);
}
GeneratedField::Component => {
if component__.is_some() {
return Err(serde::de::Error::duplicate_field("component"));
}
component__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Unit => {
if unit__.is_some() {
return Err(serde::de::Error::duplicate_field("unit"));
}
unit__ = map_.next_value()?;
}
GeneratedField::EnumTypes => {
if enum_types__.is_some() {
return Err(serde::de::Error::duplicate_field("enumTypes"));
}
enum_types__ = Some(map_.next_value()?);
}
GeneratedField::BitFieldElements => {
if bit_field_elements__.is_some() {
return Err(serde::de::Error::duplicate_field("bitFieldElements"));
}
bit_field_elements__ = Some(map_.next_value()?);
}
}
}
Ok(metadata::Channel {
channel_id: channel_id__.unwrap_or_default(),
component: component__.unwrap_or_default(),
name: name__.unwrap_or_default(),
unit: unit__,
enum_types: enum_types__.unwrap_or_default(),
bit_field_elements: bit_field_elements__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Metadata.Channel", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for metadata::channel::Unit {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.name.is_empty() {
len += 1;
}
if !self.abbreviated_name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Metadata.Channel.Unit", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.abbreviated_name.is_empty() {
struct_ser.serialize_field("abbreviatedName", &self.abbreviated_name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for metadata::channel::Unit {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"abbreviated_name",
"abbreviatedName",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
AbbreviatedName,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"name" => Ok(GeneratedField::Name),
"abbreviatedName" | "abbreviated_name" => Ok(GeneratedField::AbbreviatedName),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = metadata::channel::Unit;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Metadata.Channel.Unit")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<metadata::channel::Unit, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut abbreviated_name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::AbbreviatedName => {
if abbreviated_name__.is_some() {
return Err(serde::de::Error::duplicate_field("abbreviatedName"));
}
abbreviated_name__ = Some(map_.next_value()?);
}
}
}
Ok(metadata::channel::Unit {
name: name__.unwrap_or_default(),
abbreviated_name: abbreviated_name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Metadata.Channel.Unit", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for metadata::Run {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if !self.run_id.is_empty() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Metadata.Run", len)?;
if !self.run_id.is_empty() {
struct_ser.serialize_field("runId", &self.run_id)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for metadata::Run {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"run_id",
"runId",
"name",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
RunId,
Name,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"runId" | "run_id" => Ok(GeneratedField::RunId),
"name" => Ok(GeneratedField::Name),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = metadata::Run;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Metadata.Run")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<metadata::Run, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut run_id__ = None;
let mut name__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::RunId => {
if run_id__.is_some() {
return Err(serde::de::Error::duplicate_field("runId"));
}
run_id__ = Some(map_.next_value()?);
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
}
}
Ok(metadata::Run {
run_id: run_id__.unwrap_or_default(),
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Metadata.Run", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Query {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.query.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Query", len)?;
if let Some(v) = self.query.as_ref() {
match v {
query::Query::Channel(v) => {
struct_ser.serialize_field("channel", v)?;
}
query::Query::CalculatedChannel(v) => {
struct_ser.serialize_field("calculatedChannel", v)?;
}
}
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Query {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"channel",
"calculated_channel",
"calculatedChannel",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Channel,
CalculatedChannel,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"channel" => Ok(GeneratedField::Channel),
"calculatedChannel" | "calculated_channel" => Ok(GeneratedField::CalculatedChannel),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Query;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Query")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Query, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut query__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Channel => {
if query__.is_some() {
return Err(serde::de::Error::duplicate_field("channel"));
}
query__ = map_.next_value::<::std::option::Option<_>>()?.map(query::Query::Channel)
;
}
GeneratedField::CalculatedChannel => {
if query__.is_some() {
return Err(serde::de::Error::duplicate_field("calculatedChannel"));
}
query__ = map_.next_value::<::std::option::Option<_>>()?.map(query::Query::CalculatedChannel)
;
}
}
}
Ok(Query {
query: query__,
})
}
}
deserializer.deserialize_struct("sift.data.v1.Query", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StringValue {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if !self.value.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.StringValue", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if !self.value.is_empty() {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StringValue {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StringValue;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.StringValue")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StringValue, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ = Some(map_.next_value()?);
}
}
}
Ok(StringValue {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.StringValue", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for StringValues {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.StringValues", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for StringValues {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = StringValues;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.StringValues")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<StringValues, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(StringValues {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.StringValues", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Uint32Value {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Uint32Value", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
struct_ser.serialize_field("value", &self.value)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Uint32Value {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Uint32Value;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Uint32Value")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint32Value, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(Uint32Value {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Uint32Value", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Uint32Values {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Uint32Values", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Uint32Values {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Uint32Values;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Uint32Values")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint32Values, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(Uint32Values {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Uint32Values", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Uint64Value {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.timestamp.is_some() {
len += 1;
}
if self.value != 0 {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Uint64Value", len)?;
if let Some(v) = self.timestamp.as_ref() {
struct_ser.serialize_field("timestamp", v)?;
}
if self.value != 0 {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("value", ToString::to_string(&self.value).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Uint64Value {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"timestamp",
"value",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Timestamp,
Value,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"timestamp" => Ok(GeneratedField::Timestamp),
"value" => Ok(GeneratedField::Value),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Uint64Value;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Uint64Value")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint64Value, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut timestamp__ = None;
let mut value__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Timestamp => {
if timestamp__.is_some() {
return Err(serde::de::Error::duplicate_field("timestamp"));
}
timestamp__ = map_.next_value()?;
}
GeneratedField::Value => {
if value__.is_some() {
return Err(serde::de::Error::duplicate_field("value"));
}
value__ =
Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
;
}
}
}
Ok(Uint64Value {
timestamp: timestamp__,
value: value__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Uint64Value", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Uint64Values {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if self.metadata.is_some() {
len += 1;
}
if !self.values.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.data.v1.Uint64Values", len)?;
if let Some(v) = self.metadata.as_ref() {
struct_ser.serialize_field("metadata", v)?;
}
if !self.values.is_empty() {
struct_ser.serialize_field("values", &self.values)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Uint64Values {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"metadata",
"values",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Metadata,
Values,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"metadata" => Ok(GeneratedField::Metadata),
"values" => Ok(GeneratedField::Values),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Uint64Values;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.data.v1.Uint64Values")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Uint64Values, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut metadata__ = None;
let mut values__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Metadata => {
if metadata__.is_some() {
return Err(serde::de::Error::duplicate_field("metadata"));
}
metadata__ = map_.next_value()?;
}
GeneratedField::Values => {
if values__.is_some() {
return Err(serde::de::Error::duplicate_field("values"));
}
values__ = Some(map_.next_value()?);
}
}
}
Ok(Uint64Values {
metadata: metadata__,
values: values__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.data.v1.Uint64Values", FIELDS, GeneratedVisitor)
}
}