impl serde::Serialize for Action {
#[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 => "ACTION_UNSPECIFIED",
Self::Add => "ADD",
Self::Remove => "REMOVE",
Self::Update => "UPDATE",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for Action {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"ACTION_UNSPECIFIED",
"ADD",
"REMOVE",
"UPDATE",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Action;
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 {
"ACTION_UNSPECIFIED" => Ok(Action::Unspecified),
"ADD" => Ok(Action::Add),
"REMOVE" => Ok(Action::Remove),
"UPDATE" => Ok(Action::Update),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for CreateShareRequest {
#[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.comment.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.CreateShareRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for CreateShareRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"comment",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Comment,
__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),
"comment" => Ok(GeneratedField::Comment),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = CreateShareRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.CreateShareRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<CreateShareRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut comment__ = 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::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(CreateShareRequest {
name: name__.unwrap_or_default(),
comment: comment__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.CreateShareRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DataObject {
#[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.data_object_type != 0 {
len += 1;
}
if self.added_at.is_some() {
len += 1;
}
if self.added_by.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.shared_as.is_some() {
len += 1;
}
if !self.partitions.is_empty() {
len += 1;
}
if self.enable_cdf.is_some() {
len += 1;
}
if self.history_data_sharing_status.is_some() {
len += 1;
}
if self.start_version.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.DataObject", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if self.data_object_type != 0 {
let v = DataObjectType::try_from(self.data_object_type)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.data_object_type)))?;
struct_ser.serialize_field("data_object_type", &v)?;
}
if let Some(v) = self.added_at.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("added_at", ToString::to_string(&v).as_str())?;
}
if let Some(v) = self.added_by.as_ref() {
struct_ser.serialize_field("added_by", v)?;
}
if let Some(v) = self.comment.as_ref() {
struct_ser.serialize_field("comment", v)?;
}
if let Some(v) = self.shared_as.as_ref() {
struct_ser.serialize_field("shared_as", v)?;
}
if !self.partitions.is_empty() {
struct_ser.serialize_field("partitions", &self.partitions)?;
}
if let Some(v) = self.enable_cdf.as_ref() {
struct_ser.serialize_field("enable_cdf", v)?;
}
if let Some(v) = self.history_data_sharing_status.as_ref() {
let v = HistoryStatus::try_from(*v)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
struct_ser.serialize_field("history_data_sharing_status", &v)?;
}
if let Some(v) = self.start_version.as_ref() {
#[allow(clippy::needless_borrow)]
#[allow(clippy::needless_borrows_for_generic_args)]
struct_ser.serialize_field("start_version", ToString::to_string(&v).as_str())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DataObject {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"data_object_type",
"dataObjectType",
"added_at",
"addedAt",
"added_by",
"addedBy",
"comment",
"shared_as",
"sharedAs",
"partitions",
"enable_cdf",
"enableCdf",
"history_data_sharing_status",
"historyDataSharingStatus",
"start_version",
"startVersion",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
DataObjectType,
AddedAt,
AddedBy,
Comment,
SharedAs,
Partitions,
EnableCdf,
HistoryDataSharingStatus,
StartVersion,
__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),
"dataObjectType" | "data_object_type" => Ok(GeneratedField::DataObjectType),
"addedAt" | "added_at" => Ok(GeneratedField::AddedAt),
"addedBy" | "added_by" => Ok(GeneratedField::AddedBy),
"comment" => Ok(GeneratedField::Comment),
"sharedAs" | "shared_as" => Ok(GeneratedField::SharedAs),
"partitions" => Ok(GeneratedField::Partitions),
"enableCdf" | "enable_cdf" => Ok(GeneratedField::EnableCdf),
"historyDataSharingStatus" | "history_data_sharing_status" => Ok(GeneratedField::HistoryDataSharingStatus),
"startVersion" | "start_version" => Ok(GeneratedField::StartVersion),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DataObject;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.DataObject")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataObject, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut data_object_type__ = None;
let mut added_at__ = None;
let mut added_by__ = None;
let mut comment__ = None;
let mut shared_as__ = None;
let mut partitions__ = None;
let mut enable_cdf__ = None;
let mut history_data_sharing_status__ = None;
let mut start_version__ = 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::DataObjectType => {
if data_object_type__.is_some() {
return Err(serde::de::Error::duplicate_field("dataObjectType"));
}
data_object_type__ = Some(map_.next_value::<DataObjectType>()? as i32);
}
GeneratedField::AddedAt => {
if added_at__.is_some() {
return Err(serde::de::Error::duplicate_field("addedAt"));
}
added_at__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::AddedBy => {
if added_by__.is_some() {
return Err(serde::de::Error::duplicate_field("addedBy"));
}
added_by__ = map_.next_value()?;
}
GeneratedField::Comment => {
if comment__.is_some() {
return Err(serde::de::Error::duplicate_field("comment"));
}
comment__ = map_.next_value()?;
}
GeneratedField::SharedAs => {
if shared_as__.is_some() {
return Err(serde::de::Error::duplicate_field("sharedAs"));
}
shared_as__ = map_.next_value()?;
}
GeneratedField::Partitions => {
if partitions__.is_some() {
return Err(serde::de::Error::duplicate_field("partitions"));
}
partitions__ = Some(map_.next_value()?);
}
GeneratedField::EnableCdf => {
if enable_cdf__.is_some() {
return Err(serde::de::Error::duplicate_field("enableCdf"));
}
enable_cdf__ = map_.next_value()?;
}
GeneratedField::HistoryDataSharingStatus => {
if history_data_sharing_status__.is_some() {
return Err(serde::de::Error::duplicate_field("historyDataSharingStatus"));
}
history_data_sharing_status__ = map_.next_value::<::std::option::Option<HistoryStatus>>()?.map(|x| x as i32);
}
GeneratedField::StartVersion => {
if start_version__.is_some() {
return Err(serde::de::Error::duplicate_field("startVersion"));
}
start_version__ =
map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DataObject {
name: name__.unwrap_or_default(),
data_object_type: data_object_type__.unwrap_or_default(),
added_at: added_at__,
added_by: added_by__,
comment: comment__,
shared_as: shared_as__,
partitions: partitions__.unwrap_or_default(),
enable_cdf: enable_cdf__,
history_data_sharing_status: history_data_sharing_status__,
start_version: start_version__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.DataObject", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DataObjectType {
#[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 => "DATA_OBJECT_TYPE_UNSPECIFIED",
Self::Table => "TABLE",
Self::Schema => "SCHEMA",
Self::Volume => "VOLUME",
Self::AgentSkill => "AGENT_SKILL",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for DataObjectType {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"DATA_OBJECT_TYPE_UNSPECIFIED",
"TABLE",
"SCHEMA",
"VOLUME",
"AGENT_SKILL",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DataObjectType;
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 {
"DATA_OBJECT_TYPE_UNSPECIFIED" => Ok(DataObjectType::Unspecified),
"TABLE" => Ok(DataObjectType::Table),
"SCHEMA" => Ok(DataObjectType::Schema),
"VOLUME" => Ok(DataObjectType::Volume),
"AGENT_SKILL" => Ok(DataObjectType::AgentSkill),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for DataObjectUpdate {
#[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.action != 0 {
len += 1;
}
if self.data_object.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.DataObjectUpdate", len)?;
if self.action != 0 {
let v = Action::try_from(self.action)
.map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.action)))?;
struct_ser.serialize_field("action", &v)?;
}
if let Some(v) = self.data_object.as_ref() {
struct_ser.serialize_field("data_object", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DataObjectUpdate {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"action",
"data_object",
"dataObject",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Action,
DataObject,
__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 {
"action" => Ok(GeneratedField::Action),
"dataObject" | "data_object" => Ok(GeneratedField::DataObject),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = DataObjectUpdate;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.DataObjectUpdate")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DataObjectUpdate, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut action__ = None;
let mut data_object__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Action => {
if action__.is_some() {
return Err(serde::de::Error::duplicate_field("action"));
}
action__ = Some(map_.next_value::<Action>()? as i32);
}
GeneratedField::DataObject => {
if data_object__.is_some() {
return Err(serde::de::Error::duplicate_field("dataObject"));
}
data_object__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(DataObjectUpdate {
action: action__.unwrap_or_default(),
data_object: data_object__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.DataObjectUpdate", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for DeleteShareRequest {
#[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.shares.v1.DeleteShareRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for DeleteShareRequest {
#[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 = DeleteShareRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.DeleteShareRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteShareRequest, 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(DeleteShareRequest {
name: name__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.DeleteShareRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetPermissionsRequest {
#[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.max_results.is_some() {
len += 1;
}
if self.page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.GetPermissionsRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
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)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetPermissionsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"max_results",
"maxResults",
"page_token",
"pageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
MaxResults,
PageToken,
__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),
"maxResults" | "max_results" => Ok(GeneratedField::MaxResults),
"pageToken" | "page_token" => Ok(GeneratedField::PageToken),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetPermissionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.GetPermissionsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetPermissionsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut max_results__ = None;
let mut page_token__ = 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::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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetPermissionsRequest {
name: name__.unwrap_or_default(),
max_results: max_results__,
page_token: page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.GetPermissionsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetPermissionsResponse {
#[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.privilege_assignments.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.GetPermissionsResponse", len)?;
if !self.privilege_assignments.is_empty() {
struct_ser.serialize_field("privilege_assignments", &self.privilege_assignments)?;
}
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 GetPermissionsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"privilege_assignments",
"privilegeAssignments",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PrivilegeAssignments,
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 {
"privilegeAssignments" | "privilege_assignments" => Ok(GeneratedField::PrivilegeAssignments),
"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 = GetPermissionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.GetPermissionsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetPermissionsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut privilege_assignments__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PrivilegeAssignments => {
if privilege_assignments__.is_some() {
return Err(serde::de::Error::duplicate_field("privilegeAssignments"));
}
privilege_assignments__ = 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(GetPermissionsResponse {
privilege_assignments: privilege_assignments__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.GetPermissionsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GetShareRequest {
#[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.include_shared_data.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.GetShareRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if let Some(v) = self.include_shared_data.as_ref() {
struct_ser.serialize_field("include_shared_data", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GetShareRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"include_shared_data",
"includeSharedData",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
IncludeSharedData,
__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),
"includeSharedData" | "include_shared_data" => Ok(GeneratedField::IncludeSharedData),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GetShareRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.GetShareRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetShareRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut include_shared_data__ = 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::IncludeSharedData => {
if include_shared_data__.is_some() {
return Err(serde::de::Error::duplicate_field("includeSharedData"));
}
include_shared_data__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(GetShareRequest {
name: name__.unwrap_or_default(),
include_shared_data: include_shared_data__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.GetShareRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for HistoryStatus {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
let variant = match self {
Self::Disabled => "DISABLED",
Self::Enabled => "ENABLED",
};
serializer.serialize_str(variant)
}
}
impl<'de> serde::Deserialize<'de> for HistoryStatus {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"DISABLED",
"ENABLED",
];
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = HistoryStatus;
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 {
"DISABLED" => Ok(HistoryStatus::Disabled),
"ENABLED" => Ok(HistoryStatus::Enabled),
_ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
}
}
}
deserializer.deserialize_any(GeneratedVisitor)
}
}
impl serde::Serialize for ListSharesRequest {
#[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;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.ListSharesRequest", 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)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ListSharesRequest {
#[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",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
MaxResults,
PageToken,
__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),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ListSharesRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.ListSharesRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSharesRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut max_results__ = None;
let mut page_token__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(ListSharesRequest {
max_results: max_results__,
page_token: page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.ListSharesRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ListSharesResponse {
#[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.shares.is_empty() {
len += 1;
}
if self.next_page_token.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.ListSharesResponse", len)?;
if !self.shares.is_empty() {
struct_ser.serialize_field("shares", &self.shares)?;
}
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 ListSharesResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"shares",
"next_page_token",
"nextPageToken",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Shares,
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 {
"shares" => Ok(GeneratedField::Shares),
"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 = ListSharesResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.ListSharesResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListSharesResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut shares__ = None;
let mut next_page_token__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Shares => {
if shares__.is_some() {
return Err(serde::de::Error::duplicate_field("shares"));
}
shares__ = 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(ListSharesResponse {
shares: shares__.unwrap_or_default(),
next_page_token: next_page_token__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.ListSharesResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PermissionsChange {
#[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.principal.is_empty() {
len += 1;
}
if !self.add.is_empty() {
len += 1;
}
if !self.remove.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.PermissionsChange", len)?;
if !self.principal.is_empty() {
struct_ser.serialize_field("principal", &self.principal)?;
}
if !self.add.is_empty() {
struct_ser.serialize_field("add", &self.add)?;
}
if !self.remove.is_empty() {
struct_ser.serialize_field("remove", &self.remove)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for PermissionsChange {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"principal",
"add",
"remove",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Principal,
Add,
Remove,
__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 {
"principal" => Ok(GeneratedField::Principal),
"add" => Ok(GeneratedField::Add),
"remove" => Ok(GeneratedField::Remove),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PermissionsChange;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.PermissionsChange")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<PermissionsChange, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut principal__ = None;
let mut add__ = None;
let mut remove__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Principal => {
if principal__.is_some() {
return Err(serde::de::Error::duplicate_field("principal"));
}
principal__ = Some(map_.next_value()?);
}
GeneratedField::Add => {
if add__.is_some() {
return Err(serde::de::Error::duplicate_field("add"));
}
add__ = Some(map_.next_value()?);
}
GeneratedField::Remove => {
if remove__.is_some() {
return Err(serde::de::Error::duplicate_field("remove"));
}
remove__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(PermissionsChange {
principal: principal__.unwrap_or_default(),
add: add__.unwrap_or_default(),
remove: remove__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.PermissionsChange", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for PrivilegeAssignment {
#[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.principal.is_empty() {
len += 1;
}
if !self.privileges.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.PrivilegeAssignment", len)?;
if !self.principal.is_empty() {
struct_ser.serialize_field("principal", &self.principal)?;
}
if !self.privileges.is_empty() {
struct_ser.serialize_field("privileges", &self.privileges)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for PrivilegeAssignment {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"principal",
"privileges",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Principal,
Privileges,
__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 {
"principal" => Ok(GeneratedField::Principal),
"privileges" => Ok(GeneratedField::Privileges),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = PrivilegeAssignment;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.PrivilegeAssignment")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<PrivilegeAssignment, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut principal__ = None;
let mut privileges__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Principal => {
if principal__.is_some() {
return Err(serde::de::Error::duplicate_field("principal"));
}
principal__ = Some(map_.next_value()?);
}
GeneratedField::Privileges => {
if privileges__.is_some() {
return Err(serde::de::Error::duplicate_field("privileges"));
}
privileges__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(PrivilegeAssignment {
principal: principal__.unwrap_or_default(),
privileges: privileges__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.PrivilegeAssignment", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Share {
#[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.id.is_some() {
len += 1;
}
if !self.name.is_empty() {
len += 1;
}
if !self.objects.is_empty() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
if self.storage_location.is_some() {
len += 1;
}
if self.storage_root.is_some() {
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;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.Share", len)?;
if let Some(v) = self.id.as_ref() {
struct_ser.serialize_field("id", v)?;
}
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.objects.is_empty() {
struct_ser.serialize_field("objects", &self.objects)?;
}
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.storage_location.as_ref() {
struct_ser.serialize_field("storage_location", v)?;
}
if let Some(v) = self.storage_root.as_ref() {
struct_ser.serialize_field("storage_root", v)?;
}
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)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Share {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"id",
"name",
"objects",
"owner",
"comment",
"storage_location",
"storageLocation",
"storage_root",
"storageRoot",
"created_at",
"createdAt",
"created_by",
"createdBy",
"updated_at",
"updatedAt",
"updated_by",
"updatedBy",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Id,
Name,
Objects,
Owner,
Comment,
StorageLocation,
StorageRoot,
CreatedAt,
CreatedBy,
UpdatedAt,
UpdatedBy,
__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 {
"id" => Ok(GeneratedField::Id),
"name" => Ok(GeneratedField::Name),
"objects" => Ok(GeneratedField::Objects),
"owner" => Ok(GeneratedField::Owner),
"comment" => Ok(GeneratedField::Comment),
"storageLocation" | "storage_location" => Ok(GeneratedField::StorageLocation),
"storageRoot" | "storage_root" => Ok(GeneratedField::StorageRoot),
"createdAt" | "created_at" => Ok(GeneratedField::CreatedAt),
"createdBy" | "created_by" => Ok(GeneratedField::CreatedBy),
"updatedAt" | "updated_at" => Ok(GeneratedField::UpdatedAt),
"updatedBy" | "updated_by" => Ok(GeneratedField::UpdatedBy),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Share;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.Share")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<Share, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut id__ = None;
let mut name__ = None;
let mut objects__ = None;
let mut owner__ = None;
let mut comment__ = None;
let mut storage_location__ = None;
let mut storage_root__ = None;
let mut created_at__ = None;
let mut created_by__ = None;
let mut updated_at__ = None;
let mut updated_by__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::Id => {
if id__.is_some() {
return Err(serde::de::Error::duplicate_field("id"));
}
id__ = map_.next_value()?;
}
GeneratedField::Name => {
if name__.is_some() {
return Err(serde::de::Error::duplicate_field("name"));
}
name__ = Some(map_.next_value()?);
}
GeneratedField::Objects => {
if objects__.is_some() {
return Err(serde::de::Error::duplicate_field("objects"));
}
objects__ = Some(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::StorageLocation => {
if storage_location__.is_some() {
return Err(serde::de::Error::duplicate_field("storageLocation"));
}
storage_location__ = map_.next_value()?;
}
GeneratedField::StorageRoot => {
if storage_root__.is_some() {
return Err(serde::de::Error::duplicate_field("storageRoot"));
}
storage_root__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(Share {
id: id__,
name: name__.unwrap_or_default(),
objects: objects__.unwrap_or_default(),
owner: owner__,
comment: comment__,
storage_location: storage_location__,
storage_root: storage_root__,
created_at: created_at__,
created_by: created_by__,
updated_at: updated_at__,
updated_by: updated_by__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.Share", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdatePermissionsRequest {
#[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.changes.is_empty() {
len += 1;
}
if self.omit_permissions_list.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.UpdatePermissionsRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.changes.is_empty() {
struct_ser.serialize_field("changes", &self.changes)?;
}
if let Some(v) = self.omit_permissions_list.as_ref() {
struct_ser.serialize_field("omit_permissions_list", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdatePermissionsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"changes",
"omit_permissions_list",
"omitPermissionsList",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Changes,
OmitPermissionsList,
__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),
"changes" => Ok(GeneratedField::Changes),
"omitPermissionsList" | "omit_permissions_list" => Ok(GeneratedField::OmitPermissionsList),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdatePermissionsRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.UpdatePermissionsRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdatePermissionsRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut changes__ = None;
let mut omit_permissions_list__ = 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::Changes => {
if changes__.is_some() {
return Err(serde::de::Error::duplicate_field("changes"));
}
changes__ = Some(map_.next_value()?);
}
GeneratedField::OmitPermissionsList => {
if omit_permissions_list__.is_some() {
return Err(serde::de::Error::duplicate_field("omitPermissionsList"));
}
omit_permissions_list__ = map_.next_value()?;
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdatePermissionsRequest {
name: name__.unwrap_or_default(),
changes: changes__.unwrap_or_default(),
omit_permissions_list: omit_permissions_list__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.UpdatePermissionsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdatePermissionsResponse {
#[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.privilege_assignments.is_empty() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.UpdatePermissionsResponse", len)?;
if !self.privilege_assignments.is_empty() {
struct_ser.serialize_field("privilege_assignments", &self.privilege_assignments)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdatePermissionsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"privilege_assignments",
"privilegeAssignments",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
PrivilegeAssignments,
__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 {
"privilegeAssignments" | "privilege_assignments" => Ok(GeneratedField::PrivilegeAssignments),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdatePermissionsResponse;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.UpdatePermissionsResponse")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdatePermissionsResponse, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut privilege_assignments__ = None;
while let Some(k) = map_.next_key()? {
match k {
GeneratedField::PrivilegeAssignments => {
if privilege_assignments__.is_some() {
return Err(serde::de::Error::duplicate_field("privilegeAssignments"));
}
privilege_assignments__ = Some(map_.next_value()?);
}
GeneratedField::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdatePermissionsResponse {
privilege_assignments: privilege_assignments__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.UpdatePermissionsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for UpdateShareRequest {
#[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.updates.is_empty() {
len += 1;
}
if self.new_name.is_some() {
len += 1;
}
if self.owner.is_some() {
len += 1;
}
if self.comment.is_some() {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("unitycatalog.shares.v1.UpdateShareRequest", len)?;
if !self.name.is_empty() {
struct_ser.serialize_field("name", &self.name)?;
}
if !self.updates.is_empty() {
struct_ser.serialize_field("updates", &self.updates)?;
}
if let Some(v) = self.new_name.as_ref() {
struct_ser.serialize_field("new_name", 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)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for UpdateShareRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"name",
"updates",
"new_name",
"newName",
"owner",
"comment",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Name,
Updates,
NewName,
Owner,
Comment,
__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),
"updates" => Ok(GeneratedField::Updates),
"newName" | "new_name" => Ok(GeneratedField::NewName),
"owner" => Ok(GeneratedField::Owner),
"comment" => Ok(GeneratedField::Comment),
_ => Ok(GeneratedField::__SkipField__),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = UpdateShareRequest;
fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
formatter.write_str("struct unitycatalog.shares.v1.UpdateShareRequest")
}
fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateShareRequest, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut name__ = None;
let mut updates__ = None;
let mut new_name__ = None;
let mut owner__ = None;
let mut comment__ = 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::Updates => {
if updates__.is_some() {
return Err(serde::de::Error::duplicate_field("updates"));
}
updates__ = Some(map_.next_value()?);
}
GeneratedField::NewName => {
if new_name__.is_some() {
return Err(serde::de::Error::duplicate_field("newName"));
}
new_name__ = 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::__SkipField__ => {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
}
}
Ok(UpdateShareRequest {
name: name__.unwrap_or_default(),
updates: updates__.unwrap_or_default(),
new_name: new_name__,
owner: owner__,
comment: comment__,
})
}
}
deserializer.deserialize_struct("unitycatalog.shares.v1.UpdateShareRequest", FIELDS, GeneratedVisitor)
}
}