#[allow(unused_imports)]
use super::*;
#[doc(hidden)]
impl serde::ser::Serialize for super::FallbackInfo {
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 !wkt::internal::is_default(&self.routing_mode) {
state.serialize_entry("routingMode", &self.routing_mode)?;
}
if !wkt::internal::is_default(&self.reason) {
state.serialize_entry("reason", &self.reason)?;
}
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::GeocodingResults {
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.origin.is_some() {
state.serialize_entry("origin", &self.origin)?;
}
if self.destination.is_some() {
state.serialize_entry("destination", &self.destination)?;
}
if !self.intermediates.is_empty() {
state.serialize_entry("intermediates", &self.intermediates)?;
}
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::GeocodedWaypoint {
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.geocoder_status.is_some() {
state.serialize_entry("geocoderStatus", &self.geocoder_status)?;
}
if self.intermediate_waypoint_request_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"intermediateWaypointRequestIndex",
&__With(&self.intermediate_waypoint_request_index),
)?;
}
if !self.r#type.is_empty() {
state.serialize_entry("type", &self.r#type)?;
}
if !wkt::internal::is_default(&self.partial_match) {
state.serialize_entry("partialMatch", &self.partial_match)?;
}
if !self.place_id.is_empty() {
state.serialize_entry("placeId", &self.place_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::LocalizedTime {
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.time.is_some() {
state.serialize_entry("time", &self.time)?;
}
if !self.time_zone.is_empty() {
state.serialize_entry("timeZone", &self.time_zone)?;
}
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::Location {
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.lat_lng.is_some() {
state.serialize_entry("latLng", &self.lat_lng)?;
}
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._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::NavigationInstruction {
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 !wkt::internal::is_default(&self.maneuver) {
state.serialize_entry("maneuver", &self.maneuver)?;
}
if !self.instructions.is_empty() {
state.serialize_entry("instructions", &self.instructions)?;
}
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::Polyline {
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.encoded_polyline() {
state.serialize_entry("encodedPolyline", value)?;
}
if let Some(value) = self.geo_json_linestring() {
state.serialize_entry("geoJsonLinestring", 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::PolylineDetails {
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.tunnel_info.is_empty() {
state.serialize_entry("tunnelInfo", &self.tunnel_info)?;
}
if !self.flyover_info.is_empty() {
state.serialize_entry("flyoverInfo", &self.flyover_info)?;
}
if !self.narrow_road_info.is_empty() {
state.serialize_entry("narrowRoadInfo", &self.narrow_road_info)?;
}
if !self.bridge_info.is_empty() {
state.serialize_entry("bridgeInfo", &self.bridge_info)?;
}
if !self.skyway_info.is_empty() {
state.serialize_entry("skywayInfo", &self.skyway_info)?;
}
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::polyline_details::PolylinePointIndex {
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_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("startIndex", &__With(&self.start_index))?;
}
if self.end_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("endIndex", &__With(&self.end_index))?;
}
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::polyline_details::TunnelInfo {
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 !wkt::internal::is_default(&self.tunnel_presence) {
state.serialize_entry("tunnelPresence", &self.tunnel_presence)?;
}
if self.polyline_point_index.is_some() {
state.serialize_entry("polylinePointIndex", &self.polyline_point_index)?;
}
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::polyline_details::BridgeInfo {
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 !wkt::internal::is_default(&self.bridge_presence) {
state.serialize_entry("bridgePresence", &self.bridge_presence)?;
}
if self.polyline_point_index.is_some() {
state.serialize_entry("polylinePointIndex", &self.polyline_point_index)?;
}
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::polyline_details::SkywayInfo {
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 !wkt::internal::is_default(&self.skyway_presence) {
state.serialize_entry("skywayPresence", &self.skyway_presence)?;
}
if self.polyline_point_index.is_some() {
state.serialize_entry("polylinePointIndex", &self.polyline_point_index)?;
}
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::polyline_details::FlyoverInfo {
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 !wkt::internal::is_default(&self.flyover_presence) {
state.serialize_entry("flyoverPresence", &self.flyover_presence)?;
}
if self.polyline_point_index.is_some() {
state.serialize_entry("polylinePointIndex", &self.polyline_point_index)?;
}
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::polyline_details::NarrowRoadInfo {
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 !wkt::internal::is_default(&self.narrow_road_presence) {
state.serialize_entry("narrowRoadPresence", &self.narrow_road_presence)?;
}
if self.polyline_point_index.is_some() {
state.serialize_entry("polylinePointIndex", &self.polyline_point_index)?;
}
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::Route {
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_labels.is_empty() {
state.serialize_entry("routeLabels", &self.route_labels)?;
}
if !self.legs.is_empty() {
state.serialize_entry("legs", &self.legs)?;
}
if !wkt::internal::is_default(&self.distance_meters) {
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("distanceMeters", &__With(&self.distance_meters))?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.polyline.is_some() {
state.serialize_entry("polyline", &self.polyline)?;
}
if !self.description.is_empty() {
state.serialize_entry("description", &self.description)?;
}
if !self.warnings.is_empty() {
state.serialize_entry("warnings", &self.warnings)?;
}
if self.viewport.is_some() {
state.serialize_entry("viewport", &self.viewport)?;
}
if self.travel_advisory.is_some() {
state.serialize_entry("travelAdvisory", &self.travel_advisory)?;
}
if !self.optimized_intermediate_waypoint_index.is_empty() {
struct __With<'a>(&'a std::vec::Vec<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::<std::vec::Vec<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"optimizedIntermediateWaypointIndex",
&__With(&self.optimized_intermediate_waypoint_index),
)?;
}
if self.localized_values.is_some() {
state.serialize_entry("localizedValues", &self.localized_values)?;
}
if !self.route_token.is_empty() {
state.serialize_entry("routeToken", &self.route_token)?;
}
if self.polyline_details.is_some() {
state.serialize_entry("polylineDetails", &self.polyline_details)?;
}
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::route::RouteLocalizedValues {
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.distance.is_some() {
state.serialize_entry("distance", &self.distance)?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.transit_fare.is_some() {
state.serialize_entry("transitFare", &self.transit_fare)?;
}
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::RouteTravelAdvisory {
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.toll_info.is_some() {
state.serialize_entry("tollInfo", &self.toll_info)?;
}
if !self.speed_reading_intervals.is_empty() {
state.serialize_entry("speedReadingIntervals", &self.speed_reading_intervals)?;
}
if !wkt::internal::is_default(&self.fuel_consumption_microliters) {
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(
"fuelConsumptionMicroliters",
&__With(&self.fuel_consumption_microliters),
)?;
}
if !wkt::internal::is_default(&self.route_restrictions_partially_ignored) {
state.serialize_entry(
"routeRestrictionsPartiallyIgnored",
&self.route_restrictions_partially_ignored,
)?;
}
if self.transit_fare.is_some() {
state.serialize_entry("transitFare", &self.transit_fare)?;
}
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::RouteLegTravelAdvisory {
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.toll_info.is_some() {
state.serialize_entry("tollInfo", &self.toll_info)?;
}
if !self.speed_reading_intervals.is_empty() {
state.serialize_entry("speedReadingIntervals", &self.speed_reading_intervals)?;
}
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::RouteLegStepTravelAdvisory {
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.speed_reading_intervals.is_empty() {
state.serialize_entry("speedReadingIntervals", &self.speed_reading_intervals)?;
}
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::RouteLeg {
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 !wkt::internal::is_default(&self.distance_meters) {
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("distanceMeters", &__With(&self.distance_meters))?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.polyline.is_some() {
state.serialize_entry("polyline", &self.polyline)?;
}
if self.start_location.is_some() {
state.serialize_entry("startLocation", &self.start_location)?;
}
if self.end_location.is_some() {
state.serialize_entry("endLocation", &self.end_location)?;
}
if !self.steps.is_empty() {
state.serialize_entry("steps", &self.steps)?;
}
if self.travel_advisory.is_some() {
state.serialize_entry("travelAdvisory", &self.travel_advisory)?;
}
if self.localized_values.is_some() {
state.serialize_entry("localizedValues", &self.localized_values)?;
}
if self.steps_overview.is_some() {
state.serialize_entry("stepsOverview", &self.steps_overview)?;
}
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::route_leg::RouteLegLocalizedValues {
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.distance.is_some() {
state.serialize_entry("distance", &self.distance)?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
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::route_leg::StepsOverview {
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.multi_modal_segments.is_empty() {
state.serialize_entry("multiModalSegments", &self.multi_modal_segments)?;
}
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::route_leg::steps_overview::MultiModalSegment {
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.step_start_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("stepStartIndex", &__With(&self.step_start_index))?;
}
if self.step_end_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("stepEndIndex", &__With(&self.step_end_index))?;
}
if self.navigation_instruction.is_some() {
state.serialize_entry("navigationInstruction", &self.navigation_instruction)?;
}
if !wkt::internal::is_default(&self.travel_mode) {
state.serialize_entry("travelMode", &self.travel_mode)?;
}
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::RouteLegStep {
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 !wkt::internal::is_default(&self.distance_meters) {
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("distanceMeters", &__With(&self.distance_meters))?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.polyline.is_some() {
state.serialize_entry("polyline", &self.polyline)?;
}
if self.start_location.is_some() {
state.serialize_entry("startLocation", &self.start_location)?;
}
if self.end_location.is_some() {
state.serialize_entry("endLocation", &self.end_location)?;
}
if self.navigation_instruction.is_some() {
state.serialize_entry("navigationInstruction", &self.navigation_instruction)?;
}
if self.travel_advisory.is_some() {
state.serialize_entry("travelAdvisory", &self.travel_advisory)?;
}
if self.localized_values.is_some() {
state.serialize_entry("localizedValues", &self.localized_values)?;
}
if self.transit_details.is_some() {
state.serialize_entry("transitDetails", &self.transit_details)?;
}
if !wkt::internal::is_default(&self.travel_mode) {
state.serialize_entry("travelMode", &self.travel_mode)?;
}
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::route_leg_step::RouteLegStepLocalizedValues {
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.distance.is_some() {
state.serialize_entry("distance", &self.distance)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
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::RouteLegStepTransitDetails {
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_details.is_some() {
state.serialize_entry("stopDetails", &self.stop_details)?;
}
if self.localized_values.is_some() {
state.serialize_entry("localizedValues", &self.localized_values)?;
}
if !self.headsign.is_empty() {
state.serialize_entry("headsign", &self.headsign)?;
}
if self.headway.is_some() {
state.serialize_entry("headway", &self.headway)?;
}
if self.transit_line.is_some() {
state.serialize_entry("transitLine", &self.transit_line)?;
}
if !wkt::internal::is_default(&self.stop_count) {
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("stopCount", &__With(&self.stop_count))?;
}
if !self.trip_short_text.is_empty() {
state.serialize_entry("tripShortText", &self.trip_short_text)?;
}
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::route_leg_step_transit_details::TransitStopDetails {
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.arrival_stop.is_some() {
state.serialize_entry("arrivalStop", &self.arrival_stop)?;
}
if self.arrival_time.is_some() {
state.serialize_entry("arrivalTime", &self.arrival_time)?;
}
if self.departure_stop.is_some() {
state.serialize_entry("departureStop", &self.departure_stop)?;
}
if self.departure_time.is_some() {
state.serialize_entry("departureTime", &self.departure_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::route_leg_step_transit_details::TransitDetailsLocalizedValues
{
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.arrival_time.is_some() {
state.serialize_entry("arrivalTime", &self.arrival_time)?;
}
if self.departure_time.is_some() {
state.serialize_entry("departureTime", &self.departure_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::RouteModifiers {
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 !wkt::internal::is_default(&self.avoid_tolls) {
state.serialize_entry("avoidTolls", &self.avoid_tolls)?;
}
if !wkt::internal::is_default(&self.avoid_highways) {
state.serialize_entry("avoidHighways", &self.avoid_highways)?;
}
if !wkt::internal::is_default(&self.avoid_ferries) {
state.serialize_entry("avoidFerries", &self.avoid_ferries)?;
}
if !wkt::internal::is_default(&self.avoid_indoor) {
state.serialize_entry("avoidIndoor", &self.avoid_indoor)?;
}
if self.vehicle_info.is_some() {
state.serialize_entry("vehicleInfo", &self.vehicle_info)?;
}
if !self.toll_passes.is_empty() {
state.serialize_entry("tollPasses", &self.toll_passes)?;
}
if !wkt::internal::is_default(&self.avoid_tunnels) {
state.serialize_entry("avoidTunnels", &self.avoid_tunnels)?;
}
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::ComputeRoutesRequest {
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.origin.is_some() {
state.serialize_entry("origin", &self.origin)?;
}
if self.destination.is_some() {
state.serialize_entry("destination", &self.destination)?;
}
if !self.intermediates.is_empty() {
state.serialize_entry("intermediates", &self.intermediates)?;
}
if !wkt::internal::is_default(&self.travel_mode) {
state.serialize_entry("travelMode", &self.travel_mode)?;
}
if !wkt::internal::is_default(&self.routing_preference) {
state.serialize_entry("routingPreference", &self.routing_preference)?;
}
if !wkt::internal::is_default(&self.polyline_quality) {
state.serialize_entry("polylineQuality", &self.polyline_quality)?;
}
if !wkt::internal::is_default(&self.polyline_encoding) {
state.serialize_entry("polylineEncoding", &self.polyline_encoding)?;
}
if self.departure_time.is_some() {
state.serialize_entry("departureTime", &self.departure_time)?;
}
if self.arrival_time.is_some() {
state.serialize_entry("arrivalTime", &self.arrival_time)?;
}
if !wkt::internal::is_default(&self.compute_alternative_routes) {
state.serialize_entry("computeAlternativeRoutes", &self.compute_alternative_routes)?;
}
if self.route_modifiers.is_some() {
state.serialize_entry("routeModifiers", &self.route_modifiers)?;
}
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 !wkt::internal::is_default(&self.units) {
state.serialize_entry("units", &self.units)?;
}
if !wkt::internal::is_default(&self.optimize_waypoint_order) {
state.serialize_entry("optimizeWaypointOrder", &self.optimize_waypoint_order)?;
}
if !self.requested_reference_routes.is_empty() {
state.serialize_entry("requestedReferenceRoutes", &self.requested_reference_routes)?;
}
if !self.extra_computations.is_empty() {
state.serialize_entry("extraComputations", &self.extra_computations)?;
}
if !wkt::internal::is_default(&self.traffic_model) {
state.serialize_entry("trafficModel", &self.traffic_model)?;
}
if self.transit_preferences.is_some() {
state.serialize_entry("transitPreferences", &self.transit_preferences)?;
}
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::ComputeRoutesResponse {
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.routes.is_empty() {
state.serialize_entry("routes", &self.routes)?;
}
if self.fallback_info.is_some() {
state.serialize_entry("fallbackInfo", &self.fallback_info)?;
}
if self.geocoding_results.is_some() {
state.serialize_entry("geocodingResults", &self.geocoding_results)?;
}
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::ComputeRouteMatrixRequest {
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.origins.is_empty() {
state.serialize_entry("origins", &self.origins)?;
}
if !self.destinations.is_empty() {
state.serialize_entry("destinations", &self.destinations)?;
}
if !wkt::internal::is_default(&self.travel_mode) {
state.serialize_entry("travelMode", &self.travel_mode)?;
}
if !wkt::internal::is_default(&self.routing_preference) {
state.serialize_entry("routingPreference", &self.routing_preference)?;
}
if self.departure_time.is_some() {
state.serialize_entry("departureTime", &self.departure_time)?;
}
if self.arrival_time.is_some() {
state.serialize_entry("arrivalTime", &self.arrival_time)?;
}
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 !wkt::internal::is_default(&self.units) {
state.serialize_entry("units", &self.units)?;
}
if !self.extra_computations.is_empty() {
state.serialize_entry("extraComputations", &self.extra_computations)?;
}
if !wkt::internal::is_default(&self.traffic_model) {
state.serialize_entry("trafficModel", &self.traffic_model)?;
}
if self.transit_preferences.is_some() {
state.serialize_entry("transitPreferences", &self.transit_preferences)?;
}
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::RouteMatrixOrigin {
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.waypoint.is_some() {
state.serialize_entry("waypoint", &self.waypoint)?;
}
if self.route_modifiers.is_some() {
state.serialize_entry("routeModifiers", &self.route_modifiers)?;
}
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::RouteMatrixDestination {
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.waypoint.is_some() {
state.serialize_entry("waypoint", &self.waypoint)?;
}
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::RouteMatrixElement {
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.origin_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("originIndex", &__With(&self.origin_index))?;
}
if self.destination_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry("destinationIndex", &__With(&self.destination_index))?;
}
if self.status.is_some() {
state.serialize_entry("status", &self.status)?;
}
if !wkt::internal::is_default(&self.condition) {
state.serialize_entry("condition", &self.condition)?;
}
if !wkt::internal::is_default(&self.distance_meters) {
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("distanceMeters", &__With(&self.distance_meters))?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.travel_advisory.is_some() {
state.serialize_entry("travelAdvisory", &self.travel_advisory)?;
}
if self.fallback_info.is_some() {
state.serialize_entry("fallbackInfo", &self.fallback_info)?;
}
if self.localized_values.is_some() {
state.serialize_entry("localizedValues", &self.localized_values)?;
}
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::route_matrix_element::LocalizedValues {
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.distance.is_some() {
state.serialize_entry("distance", &self.distance)?;
}
if self.duration.is_some() {
state.serialize_entry("duration", &self.duration)?;
}
if self.static_duration.is_some() {
state.serialize_entry("staticDuration", &self.static_duration)?;
}
if self.transit_fare.is_some() {
state.serialize_entry("transitFare", &self.transit_fare)?;
}
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::SpeedReadingInterval {
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_polyline_point_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"startPolylinePointIndex",
&__With(&self.start_polyline_point_index),
)?;
}
if self.end_polyline_point_index.is_some() {
struct __With<'a>(&'a std::option::Option<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::<std::option::Option<wkt::internal::I32>>::serialize(
self.0, serializer,
)
}
}
state.serialize_entry(
"endPolylinePointIndex",
&__With(&self.end_polyline_point_index),
)?;
}
if let Some(value) = self.speed() {
state.serialize_entry("speed", 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::TollInfo {
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.estimated_price.is_empty() {
state.serialize_entry("estimatedPrice", &self.estimated_price)?;
}
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::TransitAgency {
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.phone_number.is_empty() {
state.serialize_entry("phoneNumber", &self.phone_number)?;
}
if !self.uri.is_empty() {
state.serialize_entry("uri", &self.uri)?;
}
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::TransitLine {
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.agencies.is_empty() {
state.serialize_entry("agencies", &self.agencies)?;
}
if !self.name.is_empty() {
state.serialize_entry("name", &self.name)?;
}
if !self.uri.is_empty() {
state.serialize_entry("uri", &self.uri)?;
}
if !self.color.is_empty() {
state.serialize_entry("color", &self.color)?;
}
if !self.icon_uri.is_empty() {
state.serialize_entry("iconUri", &self.icon_uri)?;
}
if !self.name_short.is_empty() {
state.serialize_entry("nameShort", &self.name_short)?;
}
if !self.text_color.is_empty() {
state.serialize_entry("textColor", &self.text_color)?;
}
if self.vehicle.is_some() {
state.serialize_entry("vehicle", &self.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::TransitStop {
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.location.is_some() {
state.serialize_entry("location", &self.location)?;
}
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::TransitVehicle {
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_some() {
state.serialize_entry("name", &self.name)?;
}
if !wkt::internal::is_default(&self.r#type) {
state.serialize_entry("type", &self.r#type)?;
}
if !self.icon_uri.is_empty() {
state.serialize_entry("iconUri", &self.icon_uri)?;
}
if !self.local_icon_uri.is_empty() {
state.serialize_entry("localIconUri", &self.local_icon_uri)?;
}
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::TransitPreferences {
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.allowed_travel_modes.is_empty() {
state.serialize_entry("allowedTravelModes", &self.allowed_travel_modes)?;
}
if !wkt::internal::is_default(&self.routing_preference) {
state.serialize_entry("routingPreference", &self.routing_preference)?;
}
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::VehicleInfo {
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 !wkt::internal::is_default(&self.emission_type) {
state.serialize_entry("emissionType", &self.emission_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::Waypoint {
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.location() {
state.serialize_entry("location", value)?;
}
if let Some(value) = self.place_id() {
state.serialize_entry("placeId", value)?;
}
if let Some(value) = self.address() {
state.serialize_entry("address", value)?;
}
if let Some(value) = self.navigation_point_token() {
state.serialize_entry("navigationPointToken", value)?;
}
if !wkt::internal::is_default(&self.via) {
state.serialize_entry("via", &self.via)?;
}
if !wkt::internal::is_default(&self.vehicle_stopover) {
state.serialize_entry("vehicleStopover", &self.vehicle_stopover)?;
}
if !wkt::internal::is_default(&self.side_of_road) {
state.serialize_entry("sideOfRoad", &self.side_of_road)?;
}
if !self._unknown_fields.is_empty() {
for (key, value) in self._unknown_fields.iter() {
state.serialize_entry(key, &value)?;
}
}
state.end()
}
}