#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::DeliveryVehicleAttribute {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.key.is_empty() {
state.serialize_entry("key", &self.key)?;
}
if !self.value.is_empty() {
state.serialize_entry("value", &self.value)?;
}
if let Some(value) = self.string_value() {
state.serialize_entry("stringValue", value)?;
}
if let Some(value) = self.bool_value() {
state.serialize_entry("boolValue", value)?;
}
if let Some(value) = self.number_value() {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numberValue", &__With(value))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeliveryVehicleLocation {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.location.is_some() {
state.serialize_entry("location", &self.location)?;
}
if self.horizontal_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("horizontalAccuracy", &__With(&self.horizontal_accuracy))?;
}
if self.latlng_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("latlngAccuracy", &__With(&self.latlng_accuracy))?;
}
if self.heading.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("heading", &__With(&self.heading))?;
}
if self.bearing_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("bearingAccuracy", &__With(&self.bearing_accuracy))?;
}
if self.heading_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("headingAccuracy", &__With(&self.heading_accuracy))?;
}
if self.altitude.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("altitude", &__With(&self.altitude))?;
}
if self.vertical_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("verticalAccuracy", &__With(&self.vertical_accuracy))?;
}
if self.altitude_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("altitudeAccuracy", &__With(&self.altitude_accuracy))?;
}
if self.speed_kmph.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("speedKmph", &__With(&self.speed_kmph))?;
}
if self.speed.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("speed", &__With(&self.speed))?;
}
if self.speed_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("speedAccuracy", &__With(&self.speed_accuracy))?;
}
if self.update_time.is_some() {
state.serialize_entry("updateTime", &self.update_time)?;
}
if self.server_time.is_some() {
state.serialize_entry("serverTime", &self.server_time)?;
}
if !wkt::internal::is_default(&self.location_sensor) {
state.serialize_entry("locationSensor", &self.location_sensor)?;
}
if self.is_road_snapped.is_some() {
state.serialize_entry("isRoadSnapped", &self.is_road_snapped)?;
}
if self.is_gps_sensor_enabled.is_some() {
state.serialize_entry("isGpsSensorEnabled", &self.is_gps_sensor_enabled)?;
}
if self.time_since_update.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("timeSinceUpdate", &__With(&self.time_since_update))?;
}
if self.num_stale_updates.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("numStaleUpdates", &__With(&self.num_stale_updates))?;
}
if self.raw_location.is_some() {
state.serialize_entry("rawLocation", &self.raw_location)?;
}
if self.raw_location_time.is_some() {
state.serialize_entry("rawLocationTime", &self.raw_location_time)?;
}
if !wkt::internal::is_default(&self.raw_location_sensor) {
state.serialize_entry("rawLocationSensor", &self.raw_location_sensor)?;
}
if self.raw_location_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("rawLocationAccuracy", &__With(&self.raw_location_accuracy))?;
}
if self.flp_location.is_some() {
state.serialize_entry("flpLocation", &self.flp_location)?;
}
if self.flp_update_time.is_some() {
state.serialize_entry("flpUpdateTime", &self.flp_update_time)?;
}
if self.flp_latlng_accuracy_meters.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"flpLatlngAccuracyMeters",
&__With(&self.flp_latlng_accuracy_meters),
)?;
}
if self.flp_heading_degrees.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("flpHeadingDegrees", &__With(&self.flp_heading_degrees))?;
}
if self.supplemental_location.is_some() {
state.serialize_entry("supplementalLocation", &self.supplemental_location)?;
}
if self.supplemental_location_time.is_some() {
state.serialize_entry("supplementalLocationTime", &self.supplemental_location_time)?;
}
if !wkt::internal::is_default(&self.supplemental_location_sensor) {
state.serialize_entry(
"supplementalLocationSensor",
&self.supplemental_location_sensor,
)?;
}
if self.supplemental_location_accuracy.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::DoubleValue>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::F64>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"supplementalLocationAccuracy",
&__With(&self.supplemental_location_accuracy),
)?;
}
if !wkt::internal::is_default(&self.road_snapped) {
state.serialize_entry("roadSnapped", &self.road_snapped)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TimeWindow {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.start_time.is_some() {
state.serialize_entry("startTime", &self.start_time)?;
}
if self.end_time.is_some() {
state.serialize_entry("endTime", &self.end_time)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TaskAttribute {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.key.is_empty() {
state.serialize_entry("key", &self.key)?;
}
if let Some(value) = self.string_value() {
state.serialize_entry("stringValue", value)?;
}
if let Some(value) = self.bool_value() {
state.serialize_entry("boolValue", value)?;
}
if let Some(value) = self.number_value() {
struct __With<'a>(&'a f64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::F64>::serialize(self.0, serializer)
}
}
state.serialize_entry("numberValue", &__With(value))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CreateDeliveryVehicleRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !self.delivery_vehicle_id.is_empty() {
state.serialize_entry("deliveryVehicleId", &self.delivery_vehicle_id)?;
}
if self.delivery_vehicle.is_some() {
state.serialize_entry("deliveryVehicle", &self.delivery_vehicle)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetDeliveryVehicleRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteDeliveryVehicleRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListDeliveryVehiclesRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !wkt::internal::is_default(&self.page_size) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
if self.viewport.is_some() {
state.serialize_entry("viewport", &self.viewport)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListDeliveryVehiclesResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.delivery_vehicles.is_empty() {
state.serialize_entry("deliveryVehicles", &self.delivery_vehicles)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !wkt::internal::is_default(&self.total_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("totalSize", &__With(&self.total_size))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateDeliveryVehicleRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if self.delivery_vehicle.is_some() {
state.serialize_entry("deliveryVehicle", &self.delivery_vehicle)?;
}
if self.update_mask.is_some() {
state.serialize_entry("updateMask", &self.update_mask)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BatchCreateTasksRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !self.requests.is_empty() {
state.serialize_entry("requests", &self.requests)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::BatchCreateTasksResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.tasks.is_empty() {
state.serialize_entry("tasks", &self.tasks)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::CreateTaskRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !self.task_id.is_empty() {
state.serialize_entry("taskId", &self.task_id)?;
}
if self.task.is_some() {
state.serialize_entry("task", &self.task)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetTaskRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeleteTaskRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::UpdateTaskRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if self.task.is_some() {
state.serialize_entry("task", &self.task)?;
}
if self.update_mask.is_some() {
state.serialize_entry("updateMask", &self.update_mask)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListTasksRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.parent.is_empty() {
state.serialize_entry("parent", &self.parent)?;
}
if !wkt::internal::is_default(&self.page_size) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("pageSize", &__With(&self.page_size))?;
}
if !self.page_token.is_empty() {
state.serialize_entry("pageToken", &self.page_token)?;
}
if !self.filter.is_empty() {
state.serialize_entry("filter", &self.filter)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::ListTasksResponse {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.tasks.is_empty() {
state.serialize_entry("tasks", &self.tasks)?;
}
if !self.next_page_token.is_empty() {
state.serialize_entry("nextPageToken", &self.next_page_token)?;
}
if !wkt::internal::is_default(&self.total_size) {
struct __With<'a>(&'a i64);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I64>::serialize(self.0, serializer)
}
}
state.serialize_entry("totalSize", &__With(&self.total_size))?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::GetTaskTrackingInfoRequest {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.header.is_some() {
state.serialize_entry("header", &self.header)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeliveryVehicle {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if self.last_location.is_some() {
state.serialize_entry("lastLocation", &self.last_location)?;
}
if !self.past_locations.is_empty() {
state.serialize_entry("pastLocations", &self.past_locations)?;
}
if !wkt::internal::is_default(&self.navigation_status) {
state.serialize_entry("navigationStatus", &self.navigation_status)?;
}
if !self.current_route_segment.is_empty() {
struct __With<'a>(&'a ::bytes::Bytes);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<serde_with::base64::Base64>::serialize(self.0, serializer)
}
}
state.serialize_entry("currentRouteSegment", &__With(&self.current_route_segment))?;
}
if self.current_route_segment_end_point.is_some() {
state.serialize_entry(
"currentRouteSegmentEndPoint",
&self.current_route_segment_end_point,
)?;
}
if self.remaining_distance_meters.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"remainingDistanceMeters",
&__With(&self.remaining_distance_meters),
)?;
}
if self.remaining_duration.is_some() {
state.serialize_entry("remainingDuration", &self.remaining_duration)?;
}
if !self.remaining_vehicle_journey_segments.is_empty() {
state.serialize_entry(
"remainingVehicleJourneySegments",
&self.remaining_vehicle_journey_segments,
)?;
}
if !self.attributes.is_empty() {
state.serialize_entry("attributes", &self.attributes)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::LocationInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.point.is_some() {
state.serialize_entry("point", &self.point)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::VehicleJourneySegment {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.stop.is_some() {
state.serialize_entry("stop", &self.stop)?;
}
if self.driving_distance_meters.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"drivingDistanceMeters",
&__With(&self.driving_distance_meters),
)?;
}
if self.driving_duration.is_some() {
state.serialize_entry("drivingDuration", &self.driving_duration)?;
}
if !self.path.is_empty() {
state.serialize_entry("path", &self.path)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::VehicleStop {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.planned_location.is_some() {
state.serialize_entry("plannedLocation", &self.planned_location)?;
}
if !self.tasks.is_empty() {
state.serialize_entry("tasks", &self.tasks)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::vehicle_stop::TaskInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.task_id.is_empty() {
state.serialize_entry("taskId", &self.task_id)?;
}
if self.task_duration.is_some() {
state.serialize_entry("taskDuration", &self.task_duration)?;
}
if self.target_time_window.is_some() {
state.serialize_entry("targetTimeWindow", &self.target_time_window)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::DeliveryRequestHeader {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.language_code.is_empty() {
state.serialize_entry("languageCode", &self.language_code)?;
}
if !self.region_code.is_empty() {
state.serialize_entry("regionCode", &self.region_code)?;
}
if !self.sdk_version.is_empty() {
state.serialize_entry("sdkVersion", &self.sdk_version)?;
}
if !self.os_version.is_empty() {
state.serialize_entry("osVersion", &self.os_version)?;
}
if !self.device_model.is_empty() {
state.serialize_entry("deviceModel", &self.device_model)?;
}
if !wkt::internal::is_default(&self.sdk_type) {
state.serialize_entry("sdkType", &self.sdk_type)?;
}
if !self.maps_sdk_version.is_empty() {
state.serialize_entry("mapsSdkVersion", &self.maps_sdk_version)?;
}
if !self.nav_sdk_version.is_empty() {
state.serialize_entry("navSdkVersion", &self.nav_sdk_version)?;
}
if !wkt::internal::is_default(&self.platform) {
state.serialize_entry("platform", &self.platform)?;
}
if !self.manufacturer.is_empty() {
state.serialize_entry("manufacturer", &self.manufacturer)?;
}
if !wkt::internal::is_default(&self.android_api_level) {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("androidApiLevel", &__With(&self.android_api_level))?;
}
if !self.trace_id.is_empty() {
state.serialize_entry("traceId", &self.trace_id)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TaskTrackingInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self.tracking_id.is_empty() {
state.serialize_entry("trackingId", &self.tracking_id)?;
}
if self.vehicle_location.is_some() {
state.serialize_entry("vehicleLocation", &self.vehicle_location)?;
}
if !self.route_polyline_points.is_empty() {
state.serialize_entry("routePolylinePoints", &self.route_polyline_points)?;
}
if self.remaining_stop_count.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("remainingStopCount", &__With(&self.remaining_stop_count))?;
}
if self.remaining_driving_distance_meters.is_some() {
struct __With<'a>(&'a std::option::Option<wkt::Int32Value>);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"remainingDrivingDistanceMeters",
&__With(&self.remaining_driving_distance_meters),
)?;
}
if self.estimated_arrival_time.is_some() {
state.serialize_entry("estimatedArrivalTime", &self.estimated_arrival_time)?;
}
if self.estimated_task_completion_time.is_some() {
state.serialize_entry(
"estimatedTaskCompletionTime",
&self.estimated_task_completion_time,
)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if !wkt::internal::is_default(&self.task_outcome) {
state.serialize_entry("taskOutcome", &self.task_outcome)?;
}
if self.task_outcome_time.is_some() {
state.serialize_entry("taskOutcomeTime", &self.task_outcome_time)?;
}
if self.planned_location.is_some() {
state.serialize_entry("plannedLocation", &self.planned_location)?;
}
if self.target_time_window.is_some() {
state.serialize_entry("targetTimeWindow", &self.target_time_window)?;
}
if !self.attributes.is_empty() {
state.serialize_entry("attributes", &self.attributes)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::Task {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.state) {
state.serialize_entry("state", &self.state)?;
}
if !wkt::internal::is_default(&self.task_outcome) {
state.serialize_entry("taskOutcome", &self.task_outcome)?;
}
if self.task_outcome_time.is_some() {
state.serialize_entry("taskOutcomeTime", &self.task_outcome_time)?;
}
if self.task_outcome_location.is_some() {
state.serialize_entry("taskOutcomeLocation", &self.task_outcome_location)?;
}
if !wkt::internal::is_default(&self.task_outcome_location_source) {
state.serialize_entry(
"taskOutcomeLocationSource",
&self.task_outcome_location_source,
)?;
}
if !self.tracking_id.is_empty() {
state.serialize_entry("trackingId", &self.tracking_id)?;
}
if !self.delivery_vehicle_id.is_empty() {
state.serialize_entry("deliveryVehicleId", &self.delivery_vehicle_id)?;
}
if self.planned_location.is_some() {
state.serialize_entry("plannedLocation", &self.planned_location)?;
}
if self.task_duration.is_some() {
state.serialize_entry("taskDuration", &self.task_duration)?;
}
if self.target_time_window.is_some() {
state.serialize_entry("targetTimeWindow", &self.target_time_window)?;
}
if self.journey_sharing_info.is_some() {
state.serialize_entry("journeySharingInfo", &self.journey_sharing_info)?;
}
if self.task_tracking_view_config.is_some() {
state.serialize_entry("taskTrackingViewConfig", &self.task_tracking_view_config)?;
}
if !self.attributes.is_empty() {
state.serialize_entry("attributes", &self.attributes)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::task::JourneySharingInfo {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if !self.remaining_vehicle_journey_segments.is_empty() {
state.serialize_entry(
"remainingVehicleJourneySegments",
&self.remaining_vehicle_journey_segments,
)?;
}
if self.last_location.is_some() {
state.serialize_entry("lastLocation", &self.last_location)?;
}
if !wkt::internal::is_default(&self.last_location_snappable) {
state.serialize_entry("lastLocationSnappable", &self.last_location_snappable)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::TaskTrackingViewConfig {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if self.route_polyline_points_visibility.is_some() {
state.serialize_entry(
"routePolylinePointsVisibility",
&self.route_polyline_points_visibility,
)?;
}
if self.estimated_arrival_time_visibility.is_some() {
state.serialize_entry(
"estimatedArrivalTimeVisibility",
&self.estimated_arrival_time_visibility,
)?;
}
if self.estimated_task_completion_time_visibility.is_some() {
state.serialize_entry(
"estimatedTaskCompletionTimeVisibility",
&self.estimated_task_completion_time_visibility,
)?;
}
if self.remaining_driving_distance_visibility.is_some() {
state.serialize_entry(
"remainingDrivingDistanceVisibility",
&self.remaining_driving_distance_visibility,
)?;
}
if self.remaining_stop_count_visibility.is_some() {
state.serialize_entry(
"remainingStopCountVisibility",
&self.remaining_stop_count_visibility,
)?;
}
if self.vehicle_location_visibility.is_some() {
state.serialize_entry(
"vehicleLocationVisibility",
&self.vehicle_location_visibility,
)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}
#[doc(hidden)]
impl serde::ser::Serialize for super::task_tracking_view_config::VisibilityOption {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
use serde::ser::SerializeMap;
#[allow(unused_imports)]
use std::option::Option::Some;
let mut state = serializer.serialize_map(std::option::Option::None)?;
if let Some(value) = self.remaining_stop_count_threshold() {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("remainingStopCountThreshold", &__With(value))?;
}
if let Some(value) = self.duration_until_estimated_arrival_time_threshold() {
state.serialize_entry("durationUntilEstimatedArrivalTimeThreshold", value)?;
}
if let Some(value) = self.remaining_driving_distance_meters_threshold() {
struct __With<'a>(&'a i32);
impl<'a> serde::ser::Serialize for __With<'a> {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serde_with::As::<wkt::internal::I32>::serialize(self.0, serializer)
}
}
state.serialize_entry("remainingDrivingDistanceMetersThreshold", &__With(value))?;
}
if let Some(value) = self.always() {
state.serialize_entry("always", value)?;
}
if let Some(value) = self.never() {
state.serialize_entry("never", value)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}