impl serde::Serialize for Comment {
#[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.comment_id.is_empty() {
len += 1;
}
if !self.resource_id.is_empty() {
len += 1;
}
if self.entity_type != 0 {
len += 1;
}
if self.created_date.is_some() {
len += 1;
}
if self.modified_date.is_some() {
len += 1;
}
if !self.created_by_user_id.is_empty() {
len += 1;
}
if !self.created_by_user_name.is_empty() {
len += 1;
}
if !self.body.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.Comment", len)?;
if !self.comment_id.is_empty() {
struct_ser.serialize_field("commentId", &self.comment_id)?;
}
if !self.resource_id.is_empty() {
struct_ser.serialize_field("resourceId", &self.resource_id)?;
}
if self.entity_type != 0 {
let v = CommentEntityType::try_from(self.entity_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.entity_type)))?;
struct_ser.serialize_field("entityType", &v)?;
}
if let Some(v) = self.created_date.as_ref() {
struct_ser.serialize_field("createdDate", v)?;
}
if let Some(v) = self.modified_date.as_ref() {
struct_ser.serialize_field("modifiedDate", v)?;
}
if !self.created_by_user_id.is_empty() {
struct_ser.serialize_field("createdByUserId", &self.created_by_user_id)?;
}
if !self.created_by_user_name.is_empty() {
struct_ser.serialize_field("createdByUserName", &self.created_by_user_name)?;
}
if !self.body.is_empty() {
struct_ser.serialize_field("body", &self.body)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Comment {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comment_id",
"commentId",
"resource_id",
"resourceId",
"entity_type",
"entityType",
"created_date",
"createdDate",
"modified_date",
"modifiedDate",
"created_by_user_id",
"createdByUserId",
"created_by_user_name",
"createdByUserName",
"body",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CommentId,
ResourceId,
EntityType,
CreatedDate,
ModifiedDate,
CreatedByUserId,
CreatedByUserName,
Body,
}
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 {
"commentId" | "comment_id" => Ok(GeneratedField::CommentId),
"resourceId" | "resource_id" => Ok(GeneratedField::ResourceId),
"entityType" | "entity_type" => Ok(GeneratedField::EntityType),
"createdDate" | "created_date" => Ok(GeneratedField::CreatedDate),
"modifiedDate" | "modified_date" => Ok(GeneratedField::ModifiedDate),
"createdByUserId" | "created_by_user_id" => Ok(GeneratedField::CreatedByUserId),
"createdByUserName" | "created_by_user_name" => Ok(GeneratedField::CreatedByUserName),
"body" => Ok(GeneratedField::Body),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Comment;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.Comment")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Comment, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comment_id__ = None;
let mut resource_id__ = None;
let mut entity_type__ = None;
let mut created_date__ = None;
let mut modified_date__ = None;
let mut created_by_user_id__ = None;
let mut created_by_user_name__ = None;
let mut body__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CommentId => {
if comment_id__.is_some() {
return Err(serde::de::Error::duplicate_field("commentId"));
}
comment_id__ = Some(map_.next_value()?);
}
GeneratedField::ResourceId => {
if resource_id__.is_some() {
return Err(serde::de::Error::duplicate_field("resourceId"));
}
resource_id__ = Some(map_.next_value()?);
}
GeneratedField::EntityType => {
if entity_type__.is_some() {
return Err(serde::de::Error::duplicate_field("entityType"));
}
entity_type__ = Some(map_.next_value::<CommentEntityType>()? as i32);
}
GeneratedField::CreatedDate => {
if created_date__.is_some() {
return Err(serde::de::Error::duplicate_field("createdDate"));
}
created_date__ = map_.next_value()?;
}
GeneratedField::ModifiedDate => {
if modified_date__.is_some() {
return Err(serde::de::Error::duplicate_field("modifiedDate"));
}
modified_date__ = map_.next_value()?;
}
GeneratedField::CreatedByUserId => {
if created_by_user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("createdByUserId"));
}
created_by_user_id__ = Some(map_.next_value()?);
}
GeneratedField::CreatedByUserName => {
if created_by_user_name__.is_some() {
return Err(serde::de::Error::duplicate_field("createdByUserName"));
}
created_by_user_name__ = Some(map_.next_value()?);
}
GeneratedField::Body => {
if body__.is_some() {
return Err(serde::de::Error::duplicate_field("body"));
}
body__ = Some(map_.next_value()?);
}
}
}
Ok(Comment {
comment_id: comment_id__.unwrap_or_default(),
resource_id: resource_id__.unwrap_or_default(),
entity_type: entity_type__.unwrap_or_default(),
created_date: created_date__,
modified_date: modified_date__,
created_by_user_id: created_by_user_id__.unwrap_or_default(),
created_by_user_name: created_by_user_name__.unwrap_or_default(),
body: body__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.Comment", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CommentBodyElement {
#[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.r#type != 0 {
len += 1;
}
if !self.text.is_empty() {
len += 1;
}
if self.user_mention.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.CommentBodyElement", len)?;
if self.r#type != 0 {
let v = CommentBodyElementType::try_from(self.r#type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
struct_ser.serialize_field("type", &v)?;
}
if !self.text.is_empty() {
struct_ser.serialize_field("text", &self.text)?;
}
if let Some(v) = self.user_mention.as_ref() {
struct_ser.serialize_field("userMention", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CommentBodyElement {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"type",
"text",
"user_mention",
"userMention",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Type,
Text,
UserMention,
}
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 {
"type" => Ok(GeneratedField::Type),
"text" => Ok(GeneratedField::Text),
"userMention" | "user_mention" => Ok(GeneratedField::UserMention),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CommentBodyElement;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.CommentBodyElement")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentBodyElement, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut r#type__ = None;
let mut text__ = None;
let mut user_mention__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Type => {
if r#type__.is_some() {
return Err(serde::de::Error::duplicate_field("type"));
}
r#type__ = Some(map_.next_value::<CommentBodyElementType>()? as i32);
}
GeneratedField::Text => {
if text__.is_some() {
return Err(serde::de::Error::duplicate_field("text"));
}
text__ = Some(map_.next_value()?);
}
GeneratedField::UserMention => {
if user_mention__.is_some() {
return Err(serde::de::Error::duplicate_field("userMention"));
}
user_mention__ = map_.next_value()?;
}
}
}
Ok(CommentBodyElement {
r#type: r#type__.unwrap_or_default(),
text: text__.unwrap_or_default(),
user_mention: user_mention__,
})
}
}
deserializer.deserialize_struct("sift.comment.v1.CommentBodyElement", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CommentBodyElementType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "COMMENT_BODY_ELEMENT_TYPE_UNSPECIFIED",
Self::Text => "COMMENT_BODY_ELEMENT_TYPE_TEXT",
Self::UserMention => "COMMENT_BODY_ELEMENT_TYPE_USER_MENTION",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for CommentBodyElementType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"COMMENT_BODY_ELEMENT_TYPE_UNSPECIFIED",
"COMMENT_BODY_ELEMENT_TYPE_TEXT",
"COMMENT_BODY_ELEMENT_TYPE_USER_MENTION",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CommentBodyElementType;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"COMMENT_BODY_ELEMENT_TYPE_UNSPECIFIED" => Ok(CommentBodyElementType::Unspecified),
"COMMENT_BODY_ELEMENT_TYPE_TEXT" => Ok(CommentBodyElementType::Text),
"COMMENT_BODY_ELEMENT_TYPE_USER_MENTION" => Ok(CommentBodyElementType::UserMention),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for CommentEntityType {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Unspecified => "COMMENT_ENTITY_TYPE_UNSPECIFIED",
Self::CanvasCellExecution => "COMMENT_ENTITY_TYPE_CANVAS_CELL_EXECUTION",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for CommentEntityType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"COMMENT_ENTITY_TYPE_UNSPECIFIED",
"COMMENT_ENTITY_TYPE_CANVAS_CELL_EXECUTION",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CommentEntityType;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
})
}
fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
i32::try_from(v)
.ok()
.and_then(|x| x.try_into().ok())
.ok_or_else(|| {
serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
})
}
fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
where
E: serde::de::Error,
{
match value {
"COMMENT_ENTITY_TYPE_UNSPECIFIED" => Ok(CommentEntityType::Unspecified),
"COMMENT_ENTITY_TYPE_CANVAS_CELL_EXECUTION" => Ok(CommentEntityType::CanvasCellExecution),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for CommentUserMention {
#[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.user_id.is_empty() {
len += 1;
}
if !self.user_email.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.CommentUserMention", len)?;
if !self.user_id.is_empty() {
struct_ser.serialize_field("userId", &self.user_id)?;
}
if !self.user_email.is_empty() {
struct_ser.serialize_field("userEmail", &self.user_email)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CommentUserMention {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"user_id",
"userId",
"user_email",
"userEmail",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
UserId,
UserEmail,
}
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 {
"userId" | "user_id" => Ok(GeneratedField::UserId),
"userEmail" | "user_email" => Ok(GeneratedField::UserEmail),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CommentUserMention;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.CommentUserMention")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CommentUserMention, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut user_id__ = None;
let mut user_email__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::UserId => {
if user_id__.is_some() {
return Err(serde::de::Error::duplicate_field("userId"));
}
user_id__ = Some(map_.next_value()?);
}
GeneratedField::UserEmail => {
if user_email__.is_some() {
return Err(serde::de::Error::duplicate_field("userEmail"));
}
user_email__ = Some(map_.next_value()?);
}
}
}
Ok(CommentUserMention {
user_id: user_id__.unwrap_or_default(),
user_email: user_email__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.CommentUserMention", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreateCommentRequest {
#[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.resource_id.is_empty() {
len += 1;
}
if self.entity_type != 0 {
len += 1;
}
if !self.body.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.CreateCommentRequest", len)?;
if !self.resource_id.is_empty() {
struct_ser.serialize_field("resourceId", &self.resource_id)?;
}
if self.entity_type != 0 {
let v = CommentEntityType::try_from(self.entity_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.entity_type)))?;
struct_ser.serialize_field("entityType", &v)?;
}
if !self.body.is_empty() {
struct_ser.serialize_field("body", &self.body)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateCommentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"resource_id",
"resourceId",
"entity_type",
"entityType",
"body",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ResourceId,
EntityType,
Body,
}
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 {
"resourceId" | "resource_id" => Ok(GeneratedField::ResourceId),
"entityType" | "entity_type" => Ok(GeneratedField::EntityType),
"body" => Ok(GeneratedField::Body),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateCommentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.CreateCommentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateCommentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut resource_id__ = None;
let mut entity_type__ = None;
let mut body__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ResourceId => {
if resource_id__.is_some() {
return Err(serde::de::Error::duplicate_field("resourceId"));
}
resource_id__ = Some(map_.next_value()?);
}
GeneratedField::EntityType => {
if entity_type__.is_some() {
return Err(serde::de::Error::duplicate_field("entityType"));
}
entity_type__ = Some(map_.next_value::<CommentEntityType>()? as i32);
}
GeneratedField::Body => {
if body__.is_some() {
return Err(serde::de::Error::duplicate_field("body"));
}
body__ = Some(map_.next_value()?);
}
}
}
Ok(CreateCommentRequest {
resource_id: resource_id__.unwrap_or_default(),
entity_type: entity_type__.unwrap_or_default(),
body: body__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.CreateCommentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for CreateCommentResponse {
#[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.comment.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.CreateCommentResponse", len)?;
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateCommentResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comment",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Comment,
}
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 {
"comment" => Ok(GeneratedField::Comment),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateCommentResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.CreateCommentResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateCommentResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comment__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
}
}
Ok(CreateCommentResponse {
comment: comment__,
})
}
}
deserializer.deserialize_struct("sift.comment.v1.CreateCommentResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteCommentRequest {
#[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.comment_id.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.DeleteCommentRequest", len)?;
if !self.comment_id.is_empty() {
struct_ser.serialize_field("commentId", &self.comment_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteCommentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comment_id",
"commentId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CommentId,
}
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 {
"commentId" | "comment_id" => Ok(GeneratedField::CommentId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteCommentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.DeleteCommentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteCommentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comment_id__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::CommentId => {
if comment_id__.is_some() {
return Err(serde::de::Error::duplicate_field("commentId"));
}
comment_id__ = Some(map_.next_value()?);
}
}
}
Ok(DeleteCommentRequest {
comment_id: comment_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.DeleteCommentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteCommentResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("sift.comment.v1.DeleteCommentResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteCommentResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
}
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,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteCommentResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.DeleteCommentResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteCommentResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(DeleteCommentResponse {
})
}
}
deserializer.deserialize_struct("sift.comment.v1.DeleteCommentResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListCommentsRequest {
#[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.page_size != 0 {
len += 1;
}
if !self.page_token.is_empty() {
len += 1;
}
if !self.filter.is_empty() {
len += 1;
}
if !self.order_by.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.ListCommentsRequest", len)?;
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)?;
}
if !self.filter.is_empty() {
struct_ser.serialize_field("filter", &self.filter)?;
}
if !self.order_by.is_empty() {
struct_ser.serialize_field("orderBy", &self.order_by)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListCommentsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"page_size",
"pageSize",
"page_token",
"pageToken",
"filter",
"order_by",
"orderBy",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PageSize,
PageToken,
Filter,
OrderBy,
}
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 {
"pageSize" | "page_size" => Ok(GeneratedField::PageSize),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"filter" => Ok(GeneratedField::Filter),
"orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListCommentsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.ListCommentsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCommentsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut page_size__ = None;
let mut page_token__ = None;
let mut filter__ = None;
let mut order_by__ = None;
while let Some(k) = map_.next_key()? {
match k {
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()?);
}
GeneratedField::Filter => {
if filter__.is_some() {
return Err(serde::de::Error::duplicate_field("filter"));
}
filter__ = Some(map_.next_value()?);
}
GeneratedField::OrderBy => {
if order_by__.is_some() {
return Err(serde::de::Error::duplicate_field("orderBy"));
}
order_by__ = Some(map_.next_value()?);
}
}
}
Ok(ListCommentsRequest {
page_size: page_size__.unwrap_or_default(),
page_token: page_token__.unwrap_or_default(),
filter: filter__.unwrap_or_default(),
order_by: order_by__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.ListCommentsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListCommentsResponse {
#[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.comments.is_empty() {
len += 1;
}
if !self.next_page_token.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.ListCommentsResponse", len)?;
if !self.comments.is_empty() {
struct_ser.serialize_field("comments", &self.comments)?;
}
if !self.next_page_token.is_empty() {
struct_ser.serialize_field("nextPageToken", &self.next_page_token)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListCommentsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comments",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Comments,
NextPageToken,
}
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 {
"comments" => Ok(GeneratedField::Comments),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListCommentsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.ListCommentsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCommentsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comments__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Comments => {
if comments__.is_some() {
return Err(serde::de::Error::duplicate_field("comments"));
}
comments__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = Some(map_.next_value()?);
}
}
}
Ok(ListCommentsResponse {
comments: comments__.unwrap_or_default(),
next_page_token: next_page_token__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.ListCommentsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateCommentRequest {
#[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.comment.is_some() {
len += 1;
}
if !self.update_mask.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.UpdateCommentRequest", len)?;
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if !self.update_mask.is_empty() {
struct_ser.serialize_field("updateMask", &self.update_mask)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateCommentRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comment",
"update_mask",
"updateMask",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Comment,
UpdateMask,
}
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 {
"comment" => Ok(GeneratedField::Comment),
"updateMask" | "update_mask" => Ok(GeneratedField::UpdateMask),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateCommentRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.UpdateCommentRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateCommentRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comment__ = None;
let mut update_mask__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::UpdateMask => {
if update_mask__.is_some() {
return Err(serde::de::Error::duplicate_field("updateMask"));
}
update_mask__ = Some(map_.next_value()?);
}
}
}
Ok(UpdateCommentRequest {
comment: comment__,
update_mask: update_mask__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("sift.comment.v1.UpdateCommentRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateCommentResponse {
#[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.comment.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("sift.comment.v1.UpdateCommentResponse", len)?;
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateCommentResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"comment",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Comment,
}
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 {
"comment" => Ok(GeneratedField::Comment),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateCommentResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct sift.comment.v1.UpdateCommentResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateCommentResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut comment__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
}
}
Ok(UpdateCommentResponse {
comment: comment__,
})
}
}
deserializer.deserialize_struct("sift.comment.v1.UpdateCommentResponse", FIELDS, GeneratedVisitor)
}
}