impl serde::Serialize for CreateExternalLocationRequest {
#[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.url.is_empty() {
len += 1;
}
if !self.credential_name.is_empty() {
len += 1;
}
if self.read_only.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.skip_validation.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.CreateExternalLocationRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.url.is_empty() {
struct_ser.serialize_field("url", &self.url)?;
}
if !self.credential_name.is_empty() {
struct_ser.serialize_field("credential_name", &self.credential_name)?;
}
if let Some(v) = self.read_only.as_ref() {
struct_ser.serialize_field("read_only", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.skip_validation.as_ref() {
struct_ser.serialize_field("skip_validation", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateExternalLocationRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"url",
"credential_name",
"credentialName",
"read_only",
"readOnly",
"comment",
"skip_validation",
"skipValidation",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Url,
CredentialName,
ReadOnly,
Comment,
SkipValidation,
__SkipField__,
}
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),
"url" => Ok(GeneratedField::Url),
"credentialName" | "credential_name" => Ok(GeneratedField::CredentialName),
"readOnly" | "read_only" => Ok(GeneratedField::ReadOnly),
"comment" => Ok(GeneratedField::Comment),
"skipValidation" | "skip_validation" => Ok(GeneratedField::SkipValidation),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateExternalLocationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.CreateExternalLocationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateExternalLocationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut url__ = None;
let mut credential_name__ = None;
let mut read_only__ = None;
let mut comment__ = None;
let mut skip_validation__ = 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::Url => {
if url__.is_some() {
return Err(serde::de::Error::duplicate_field("url"));
}
url__ = Some(map_.next_value()?);
}
GeneratedField::CredentialName => {
if credential_name__.is_some() {
return Err(serde::de::Error::duplicate_field("credentialName"));
}
credential_name__ = Some(map_.next_value()?);
}
GeneratedField::ReadOnly => {
if read_only__.is_some() {
return Err(serde::de::Error::duplicate_field("readOnly"));
}
read_only__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::SkipValidation => {
if skip_validation__.is_some() {
return Err(serde::de::Error::duplicate_field("skipValidation"));
}
skip_validation__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateExternalLocationRequest {
name: name__.unwrap_or_default(),
url: url__.unwrap_or_default(),
credential_name: credential_name__.unwrap_or_default(),
read_only: read_only__,
comment: comment__,
skip_validation: skip_validation__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.CreateExternalLocationRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteExternalLocationRequest {
#[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.force.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.DeleteExternalLocationRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.force.as_ref() {
struct_ser.serialize_field("force", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteExternalLocationRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"force",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Force,
__SkipField__,
}
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),
"force" => Ok(GeneratedField::Force),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DeleteExternalLocationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.DeleteExternalLocationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteExternalLocationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut force__ = 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::Force => {
if force__.is_some() {
return Err(serde::de::Error::duplicate_field("force"));
}
force__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DeleteExternalLocationRequest {
name: name__.unwrap_or_default(),
force: force__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.DeleteExternalLocationRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ExternalLocation {
#[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.url.is_empty() {
len += 1;
}
if !self.credential_name.is_empty() {
len += 1;
}
if self.read_only {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if !self.credential_id.is_empty() {
len += 1;
}
if self.created_at.is_some() {
len += 1;
}
if self.created_by.is_some() {
len += 1;
}
if self.updated_at.is_some() {
len += 1;
}
if self.updated_by.is_some() {
len += 1;
}
if self.browse_only.is_some() {
len += 1;
}
if self.external_location_id.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.ExternalLocation", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.url.is_empty() {
struct_ser.serialize_field("url", &self.url)?;
}
if !self.credential_name.is_empty() {
struct_ser.serialize_field("credential_name", &self.credential_name)?;
}
if self.read_only {
struct_ser.serialize_field("read_only", &self.read_only)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.owner.as_ref() {
struct_ser.serialize_field("owner", v)?;
}
if !self.credential_id.is_empty() {
struct_ser.serialize_field("credential_id", &self.credential_id)?;
}
if let Some(v) = self.created_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("created_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.created_by.as_ref() {
struct_ser.serialize_field("created_by", v)?;
}
if let Some(v) = self.updated_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("updated_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.updated_by.as_ref() {
struct_ser.serialize_field("updated_by", v)?;
}
if let Some(v) = self.browse_only.as_ref() {
struct_ser.serialize_field("browse_only", v)?;
}
if let Some(v) = self.external_location_id.as_ref() {
struct_ser.serialize_field("external_location_id", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ExternalLocation {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"url",
"credential_name",
"credentialName",
"read_only",
"readOnly",
"comment",
"owner",
"credential_id",
"credentialId",
"created_at",
"createdAt",
"created_by",
"createdBy",
"updated_at",
"updatedAt",
"updated_by",
"updatedBy",
"browse_only",
"browseOnly",
"external_location_id",
"externalLocationId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Url,
CredentialName,
ReadOnly,
Comment,
Owner,
CredentialId,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
BrowseOnly,
ExternalLocationId,
__SkipField__,
}
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),
"url" => Ok(GeneratedField::Url),
"credentialName" | "credential_name" => Ok(GeneratedField::CredentialName),
"readOnly" | "read_only" => Ok(GeneratedField::ReadOnly),
"comment" => Ok(GeneratedField::Comment),
"owner" => Ok(GeneratedField::Owner),
"credentialId" | "credential_id" => Ok(GeneratedField::CredentialId),
"createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
"createdBy" | "created_by" => Ok(GeneratedField::CreatedBy),
"updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
"updatedBy" | "updated_by" => Ok(GeneratedField::UpdatedBy),
"browseOnly" | "browse_only" => Ok(GeneratedField::BrowseOnly),
"externalLocationId" | "external_location_id" => Ok(GeneratedField::ExternalLocationId),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ExternalLocation;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.ExternalLocation")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExternalLocation, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut url__ = None;
let mut credential_name__ = None;
let mut read_only__ = None;
let mut comment__ = None;
let mut owner__ = None;
let mut credential_id__ = None;
let mut created_at__ = None;
let mut created_by__ = None;
let mut updated_at__ = None;
let mut updated_by__ = None;
let mut browse_only__ = None;
let mut external_location_id__ = 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::Url => {
if url__.is_some() {
return Err(serde::de::Error::duplicate_field("url"));
}
url__ = Some(map_.next_value()?);
}
GeneratedField::CredentialName => {
if credential_name__.is_some() {
return Err(serde::de::Error::duplicate_field("credentialName"));
}
credential_name__ = Some(map_.next_value()?);
}
GeneratedField::ReadOnly => {
if read_only__.is_some() {
return Err(serde::de::Error::duplicate_field("readOnly"));
}
read_only__ = Some(map_.next_value()?);
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::Owner => {
if owner__.is_some() {
return Err(serde::de::Error::duplicate_field("owner"));
}
owner__ = map_.next_value()?;
}
GeneratedField::CredentialId => {
if credential_id__.is_some() {
return Err(serde::de::Error::duplicate_field("credentialId"));
}
credential_id__ = Some(map_.next_value()?);
}
GeneratedField::CreatedAt => {
if created_at__.is_some() {
return Err(serde::de::Error::duplicate_field("createdAt"));
}
created_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::CreatedBy => {
if created_by__.is_some() {
return Err(serde::de::Error::duplicate_field("createdBy"));
}
created_by__ = map_.next_value()?;
}
GeneratedField::UpdatedAt => {
if updated_at__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedAt"));
}
updated_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::UpdatedBy => {
if updated_by__.is_some() {
return Err(serde::de::Error::duplicate_field("updatedBy"));
}
updated_by__ = map_.next_value()?;
}
GeneratedField::BrowseOnly => {
if browse_only__.is_some() {
return Err(serde::de::Error::duplicate_field("browseOnly"));
}
browse_only__ = map_.next_value()?;
}
GeneratedField::ExternalLocationId => {
if external_location_id__.is_some() {
return Err(serde::de::Error::duplicate_field("externalLocationId"));
}
external_location_id__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ExternalLocation {
name: name__.unwrap_or_default(),
url: url__.unwrap_or_default(),
credential_name: credential_name__.unwrap_or_default(),
read_only: read_only__.unwrap_or_default(),
comment: comment__,
owner: owner__,
credential_id: credential_id__.unwrap_or_default(),
created_at: created_at__,
created_by: created_by__,
updated_at: updated_at__,
updated_by: updated_by__,
browse_only: browse_only__,
external_location_id: external_location_id__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.ExternalLocation", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetExternalLocationRequest {
#[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;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.GetExternalLocationRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetExternalLocationRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
__SkipField__,
}
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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetExternalLocationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.GetExternalLocationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetExternalLocationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetExternalLocationRequest {
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.GetExternalLocationRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListExternalLocationsRequest {
#[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.max_results.is_some() {
len += 1;
}
if self.page_token.is_some() {
len += 1;
}
if self.include_browse.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.ListExternalLocationsRequest", len)?;
if let Some(v) = self.max_results.as_ref() {
struct_ser.serialize_field("max_results", v)?;
}
if let Some(v) = self.page_token.as_ref() {
struct_ser.serialize_field("page_token", v)?;
}
if let Some(v) = self.include_browse.as_ref() {
struct_ser.serialize_field("include_browse", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListExternalLocationsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"max_results",
"maxResults",
"page_token",
"pageToken",
"include_browse",
"includeBrowse",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MaxResults,
PageToken,
IncludeBrowse,
__SkipField__,
}
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 {
"maxResults" | "max_results" => Ok(GeneratedField::MaxResults),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
"includeBrowse" | "include_browse" => Ok(GeneratedField::IncludeBrowse),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListExternalLocationsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.ListExternalLocationsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListExternalLocationsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut max_results__ = None;
let mut page_token__ = None;
let mut include_browse__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::MaxResults => {
if max_results__.is_some() {
return Err(serde::de::Error::duplicate_field("maxResults"));
}
max_results__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::PageToken => {
if page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("pageToken"));
}
page_token__ = map_.next_value()?;
}
GeneratedField::IncludeBrowse => {
if include_browse__.is_some() {
return Err(serde::de::Error::duplicate_field("includeBrowse"));
}
include_browse__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListExternalLocationsRequest {
max_results: max_results__,
page_token: page_token__,
include_browse: include_browse__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.ListExternalLocationsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListExternalLocationsResponse {
#[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.external_locations.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.ListExternalLocationsResponse", len)?;
if !self.external_locations.is_empty() {
struct_ser.serialize_field("external_locations", &self.external_locations)?;
}
if let Some(v) = self.next_page_token.as_ref() {
struct_ser.serialize_field("next_page_token", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListExternalLocationsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"external_locations",
"externalLocations",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ExternalLocations,
NextPageToken,
__SkipField__,
}
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 {
"externalLocations" | "external_locations" => Ok(GeneratedField::ExternalLocations),
"nextPageToken" | "next_page_token" => Ok(GeneratedField::NextPageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListExternalLocationsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.ListExternalLocationsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListExternalLocationsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut external_locations__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::ExternalLocations => {
if external_locations__.is_some() {
return Err(serde::de::Error::duplicate_field("externalLocations"));
}
external_locations__ = Some(map_.next_value()?);
}
GeneratedField::NextPageToken => {
if next_page_token__.is_some() {
return Err(serde::de::Error::duplicate_field("nextPageToken"));
}
next_page_token__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListExternalLocationsResponse {
external_locations: external_locations__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.ListExternalLocationsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateExternalLocationRequest {
#[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.url.is_some() {
len += 1;
}
if self.credential_name.is_some() {
len += 1;
}
if self.read_only.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.new_name.is_some() {
len += 1;
}
if self.force.is_some() {
len += 1;
}
if self.skip_validation.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.external_locations.v1.UpdateExternalLocationRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.url.as_ref() {
struct_ser.serialize_field("url", v)?;
}
if let Some(v) = self.credential_name.as_ref() {
struct_ser.serialize_field("credential_name", v)?;
}
if let Some(v) = self.read_only.as_ref() {
struct_ser.serialize_field("read_only", v)?;
}
if let Some(v) = self.owner.as_ref() {
struct_ser.serialize_field("owner", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.new_name.as_ref() {
struct_ser.serialize_field("new_name", v)?;
}
if let Some(v) = self.force.as_ref() {
struct_ser.serialize_field("force", v)?;
}
if let Some(v) = self.skip_validation.as_ref() {
struct_ser.serialize_field("skip_validation", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateExternalLocationRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"url",
"credential_name",
"credentialName",
"read_only",
"readOnly",
"owner",
"comment",
"new_name",
"newName",
"force",
"skip_validation",
"skipValidation",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Url,
CredentialName,
ReadOnly,
Owner,
Comment,
NewName,
Force,
SkipValidation,
__SkipField__,
}
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),
"url" => Ok(GeneratedField::Url),
"credentialName" | "credential_name" => Ok(GeneratedField::CredentialName),
"readOnly" | "read_only" => Ok(GeneratedField::ReadOnly),
"owner" => Ok(GeneratedField::Owner),
"comment" => Ok(GeneratedField::Comment),
"newName" | "new_name" => Ok(GeneratedField::NewName),
"force" => Ok(GeneratedField::Force),
"skipValidation" | "skip_validation" => Ok(GeneratedField::SkipValidation),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateExternalLocationRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.external_locations.v1.UpdateExternalLocationRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateExternalLocationRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut url__ = None;
let mut credential_name__ = None;
let mut read_only__ = None;
let mut owner__ = None;
let mut comment__ = None;
let mut new_name__ = None;
let mut force__ = None;
let mut skip_validation__ = 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::Url => {
if url__.is_some() {
return Err(serde::de::Error::duplicate_field("url"));
}
url__ = map_.next_value()?;
}
GeneratedField::CredentialName => {
if credential_name__.is_some() {
return Err(serde::de::Error::duplicate_field("credentialName"));
}
credential_name__ = map_.next_value()?;
}
GeneratedField::ReadOnly => {
if read_only__.is_some() {
return Err(serde::de::Error::duplicate_field("readOnly"));
}
read_only__ = map_.next_value()?;
}
GeneratedField::Owner => {
if owner__.is_some() {
return Err(serde::de::Error::duplicate_field("owner"));
}
owner__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::NewName => {
if new_name__.is_some() {
return Err(serde::de::Error::duplicate_field("newName"));
}
new_name__ = map_.next_value()?;
}
GeneratedField::Force => {
if force__.is_some() {
return Err(serde::de::Error::duplicate_field("force"));
}
force__ = map_.next_value()?;
}
GeneratedField::SkipValidation => {
if skip_validation__.is_some() {
return Err(serde::de::Error::duplicate_field("skipValidation"));
}
skip_validation__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateExternalLocationRequest {
name: name__.unwrap_or_default(),
url: url__,
credential_name: credential_name__,
read_only: read_only__,
owner: owner__,
comment: comment__,
new_name: new_name__,
force: force__,
skip_validation: skip_validation__,
})
}
}
deserializer.deserialize_struct("unitycatalog.external_locations.v1.UpdateExternalLocationRequest", FIELDS, GeneratedVisitor)
}
}