google-cloud-logging-v2 1.15.0

// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Code generated by sidekick. DO NOT EDIT.

use super::prost::google::logging::v2::*;

impl gaxi::prost::ToProto<super::prost::google::logging::r#type::LogSeverity>
    for google_cloud_logging_type::model::LogSeverity
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "google_cloud_logging_type::model::LogSeverity",
            ))
    }
}

impl gaxi::prost::ToProto<log_entry::Payload> for crate::model::log_entry::Payload {
    type Output = log_entry::Payload;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        match self {
            Self::ProtoPayload(_) => {
                Ok(Self::Output::ProtoPayload(std::default::Default::default()))
            }
            Self::TextPayload(v) => Ok(Self::Output::TextPayload(v.to_proto()?)),
            Self::JsonPayload(v) => Ok(Self::Output::JsonPayload((*v).to_proto()?)),
        }
    }
}

impl gaxi::prost::FromProto<crate::model::log_entry::Payload> for log_entry::Payload {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::log_entry::Payload, gaxi::prost::ConvertError> {
        use crate::model::log_entry::Payload as T;
        match self {
            Self::ProtoPayload(_) => Ok(T::ProtoPayload(std::default::Default::default())),
            Self::TextPayload(v) => Ok(T::TextPayload(v.cnv()?)),
            Self::JsonPayload(v) => Ok(T::JsonPayload(std::boxed::Box::new(v.cnv()?))),
        }
    }
}

impl gaxi::prost::ToProto<LogEntry> for crate::model::LogEntry {
    type Output = LogEntry;
    fn to_proto(self) -> std::result::Result<LogEntry, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            log_name: self.log_name.to_proto()?,
            resource: self.resource.map(|v| v.to_proto()).transpose()?,
            timestamp: self.timestamp.map(|v| v.to_proto()).transpose()?,
            receive_timestamp: self.receive_timestamp.map(|v| v.to_proto()).transpose()?,
            severity: self.severity.to_proto()?,
            insert_id: self.insert_id.to_proto()?,
            http_request: self.http_request.map(|v| v.to_proto()).transpose()?,
            labels: self
                .labels
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            operation: self.operation.map(|v| v.to_proto()).transpose()?,
            trace: self.trace.to_proto()?,
            span_id: self.span_id.to_proto()?,
            trace_sampled: self.trace_sampled.to_proto()?,
            source_location: self.source_location.map(|v| v.to_proto()).transpose()?,
            split: self.split.map(|v| v.to_proto()).transpose()?,
            payload: self.payload.map(|v| v.to_proto()).transpose()?,
            ..Self::Output::default()
        })
    }
}

impl gaxi::prost::FromProto<crate::model::LogEntry> for LogEntry {
    fn cnv(self) -> std::result::Result<crate::model::LogEntry, gaxi::prost::ConvertError> {
        Ok(crate::model::LogEntry::new()
            .set_log_name(self.log_name)
            .set_or_clear_resource(self.resource.map(|v| v.cnv()).transpose()?)
            .set_or_clear_timestamp(self.timestamp.map(|v| v.cnv()).transpose()?)
            .set_or_clear_receive_timestamp(self.receive_timestamp.map(|v| v.cnv()).transpose()?)
            .set_severity(self.severity)
            .set_insert_id(self.insert_id)
            .set_or_clear_http_request(self.http_request.map(|v| v.cnv()).transpose()?)
            .set_labels(
                self.labels
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            )
            .set_or_clear_operation(self.operation.map(|v| v.cnv()).transpose()?)
            .set_trace(self.trace)
            .set_span_id(self.span_id)
            .set_trace_sampled(self.trace_sampled)
            .set_or_clear_source_location(self.source_location.map(|v| v.cnv()).transpose()?)
            .set_or_clear_split(self.split.map(|v| v.cnv()).transpose()?)
            .set_payload(self.payload.map(|v| v.cnv()).transpose()?))
    }
}

impl gaxi::prost::ToProto<LogEntryOperation> for crate::model::LogEntryOperation {
    type Output = LogEntryOperation;
    fn to_proto(self) -> std::result::Result<LogEntryOperation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            id: self.id.to_proto()?,
            producer: self.producer.to_proto()?,
            first: self.first.to_proto()?,
            last: self.last.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::LogEntryOperation> for LogEntryOperation {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::LogEntryOperation, gaxi::prost::ConvertError> {
        Ok(crate::model::LogEntryOperation::new()
            .set_id(self.id)
            .set_producer(self.producer)
            .set_first(self.first)
            .set_last(self.last))
    }
}

impl gaxi::prost::ToProto<LogEntrySourceLocation> for crate::model::LogEntrySourceLocation {
    type Output = LogEntrySourceLocation;
    fn to_proto(self) -> std::result::Result<LogEntrySourceLocation, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            file: self.file.to_proto()?,
            line: self.line.to_proto()?,
            function: self.function.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::LogEntrySourceLocation> for LogEntrySourceLocation {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::LogEntrySourceLocation, gaxi::prost::ConvertError> {
        Ok(crate::model::LogEntrySourceLocation::new()
            .set_file(self.file)
            .set_line(self.line)
            .set_function(self.function))
    }
}

impl gaxi::prost::ToProto<LogSplit> for crate::model::LogSplit {
    type Output = LogSplit;
    fn to_proto(self) -> std::result::Result<LogSplit, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            uid: self.uid.to_proto()?,
            index: self.index.to_proto()?,
            total_splits: self.total_splits.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::LogSplit> for LogSplit {
    fn cnv(self) -> std::result::Result<crate::model::LogSplit, gaxi::prost::ConvertError> {
        Ok(crate::model::LogSplit::new()
            .set_uid(self.uid)
            .set_index(self.index)
            .set_total_splits(self.total_splits))
    }
}

impl gaxi::prost::ToProto<TailLogEntriesRequest> for crate::model::TailLogEntriesRequest {
    type Output = TailLogEntriesRequest;
    fn to_proto(self) -> std::result::Result<TailLogEntriesRequest, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            resource_names: self
                .resource_names
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            filter: self.filter.to_proto()?,
            buffer_window: self.buffer_window.map(|v| v.to_proto()).transpose()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::TailLogEntriesRequest> for TailLogEntriesRequest {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::TailLogEntriesRequest, gaxi::prost::ConvertError> {
        Ok(crate::model::TailLogEntriesRequest::new()
            .set_resource_names(
                self.resource_names
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_filter(self.filter)
            .set_or_clear_buffer_window(self.buffer_window.map(|v| v.cnv()).transpose()?))
    }
}

impl gaxi::prost::ToProto<tail_log_entries_response::suppression_info::Reason>
    for crate::model::tail_log_entries_response::suppression_info::Reason
{
    type Output = i32;
    fn to_proto(self) -> std::result::Result<Self::Output, gaxi::prost::ConvertError> {
        self.value()
            .ok_or(gaxi::prost::ConvertError::EnumNoIntegerValue(
                "crate::model::tail_log_entries_response::suppression_info::Reason",
            ))
    }
}

impl gaxi::prost::ToProto<tail_log_entries_response::SuppressionInfo>
    for crate::model::tail_log_entries_response::SuppressionInfo
{
    type Output = tail_log_entries_response::SuppressionInfo;
    fn to_proto(
        self,
    ) -> std::result::Result<tail_log_entries_response::SuppressionInfo, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            reason: self.reason.to_proto()?,
            suppressed_count: self.suppressed_count.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::tail_log_entries_response::SuppressionInfo>
    for tail_log_entries_response::SuppressionInfo
{
    fn cnv(
        self,
    ) -> std::result::Result<
        crate::model::tail_log_entries_response::SuppressionInfo,
        gaxi::prost::ConvertError,
    > {
        Ok(
            crate::model::tail_log_entries_response::SuppressionInfo::new()
                .set_reason(self.reason)
                .set_suppressed_count(self.suppressed_count),
        )
    }
}

impl gaxi::prost::ToProto<TailLogEntriesResponse> for crate::model::TailLogEntriesResponse {
    type Output = TailLogEntriesResponse;
    fn to_proto(self) -> std::result::Result<TailLogEntriesResponse, gaxi::prost::ConvertError> {
        Ok(Self::Output {
            entries: self
                .entries
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            suppression_info: self
                .suppression_info
                .into_iter()
                .map(|v| v.to_proto())
                .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<crate::model::TailLogEntriesResponse> for TailLogEntriesResponse {
    fn cnv(
        self,
    ) -> std::result::Result<crate::model::TailLogEntriesResponse, gaxi::prost::ConvertError> {
        Ok(crate::model::TailLogEntriesResponse::new()
            .set_entries(
                self.entries
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            )
            .set_suppression_info(
                self.suppression_info
                    .into_iter()
                    .map(|v| v.cnv())
                    .collect::<std::result::Result<std::vec::Vec<_>, _>>()?,
            ))
    }
}

impl gaxi::prost::ToProto<super::prost::google::api::MonitoredResource>
    for google_cloud_api::model::MonitoredResource
{
    type Output = super::prost::google::api::MonitoredResource;
    fn to_proto(
        self,
    ) -> std::result::Result<super::prost::google::api::MonitoredResource, gaxi::prost::ConvertError>
    {
        Ok(Self::Output {
            r#type: self.r#type.to_proto()?,
            labels: self
                .labels
                .into_iter()
                .map(|(k, v)| gaxi::prost::pair_transpose(k.to_proto(), v.to_proto()))
                .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
        })
    }
}

impl gaxi::prost::FromProto<google_cloud_api::model::MonitoredResource>
    for super::prost::google::api::MonitoredResource
{
    fn cnv(
        self,
    ) -> std::result::Result<google_cloud_api::model::MonitoredResource, gaxi::prost::ConvertError>
    {
        Ok(google_cloud_api::model::MonitoredResource::new()
            .set_type(self.r#type)
            .set_labels(
                self.labels
                    .into_iter()
                    .map(|(k, v)| gaxi::prost::pair_transpose(k.cnv(), v.cnv()))
                    .collect::<std::result::Result<std::collections::HashMap<_, _>, _>>()?,
            ))
    }
}

impl gaxi::prost::ToProto<super::prost::google::logging::r#type::HttpRequest>
    for google_cloud_logging_type::model::HttpRequest
{
    type Output = super::prost::google::logging::r#type::HttpRequest;
    fn to_proto(
        self,
    ) -> std::result::Result<
        super::prost::google::logging::r#type::HttpRequest,
        gaxi::prost::ConvertError,
    > {
        Ok(Self::Output {
            request_method: self.request_method.to_proto()?,
            request_url: self.request_url.to_proto()?,
            request_size: self.request_size.to_proto()?,
            status: self.status.to_proto()?,
            response_size: self.response_size.to_proto()?,
            user_agent: self.user_agent.to_proto()?,
            remote_ip: self.remote_ip.to_proto()?,
            server_ip: self.server_ip.to_proto()?,
            referer: self.referer.to_proto()?,
            latency: self.latency.map(|v| v.to_proto()).transpose()?,
            cache_lookup: self.cache_lookup.to_proto()?,
            cache_hit: self.cache_hit.to_proto()?,
            cache_validated_with_origin_server: self
                .cache_validated_with_origin_server
                .to_proto()?,
            cache_fill_bytes: self.cache_fill_bytes.to_proto()?,
            protocol: self.protocol.to_proto()?,
        })
    }
}

impl gaxi::prost::FromProto<google_cloud_logging_type::model::HttpRequest>
    for super::prost::google::logging::r#type::HttpRequest
{
    fn cnv(
        self,
    ) -> std::result::Result<google_cloud_logging_type::model::HttpRequest, gaxi::prost::ConvertError>
    {
        Ok(google_cloud_logging_type::model::HttpRequest::new()
            .set_request_method(self.request_method)
            .set_request_url(self.request_url)
            .set_request_size(self.request_size)
            .set_status(self.status)
            .set_response_size(self.response_size)
            .set_user_agent(self.user_agent)
            .set_remote_ip(self.remote_ip)
            .set_server_ip(self.server_ip)
            .set_referer(self.referer)
            .set_or_clear_latency(self.latency.map(|v| v.cnv()).transpose()?)
            .set_cache_lookup(self.cache_lookup)
            .set_cache_hit(self.cache_hit)
            .set_cache_validated_with_origin_server(self.cache_validated_with_origin_server)
            .set_cache_fill_bytes(self.cache_fill_bytes)
            .set_protocol(self.protocol))
    }
}