1#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11pub type HostName = String;
16
17pub type InstanceName = String;
21
22pub type ServiceName = String;
29
30pub type SubtypeName = String;
34
35pub type TxtCharacterString = Vec<u8>;
39
40pub type TxtString = String;
44
45pub const DEFAULT_PTR_TTL: i64 = 120000000000;
46
47pub const DEFAULT_SRV_PRIORITY: u16 = 0;
48
49pub const DEFAULT_SRV_TTL: i64 = 120000000000;
50
51pub const DEFAULT_SRV_WEIGHT: u16 = 0;
52
53pub const DEFAULT_TXT_TTL: i64 = 4500000000000;
54
55pub const MAX_ADDRESSES: u32 = 64;
56
57pub const MAX_SUBTYPES: u32 = 256;
58
59pub const MAX_TEXT_STRINGS: u32 = 256;
60
61bitflags! {
62 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
64 pub struct IpVersions: u32 {
65 const V4 = 1;
67 const V6 = 2;
69 }
70}
71
72impl IpVersions {}
73
74bitflags! {
75 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
77 pub struct Media: u32 {
78 const WIRED = 1;
80 const WIRELESS = 2;
82 }
83}
84
85impl Media {}
86
87#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
89#[repr(u32)]
90pub enum Error {
91 InvalidServiceName = 1,
93 InvalidInstanceName = 2,
95 AlreadyPublishedOnSubnet = 4,
99 InvalidMedia = 5,
100}
101
102impl Error {
103 #[inline]
104 pub fn from_primitive(prim: u32) -> Option<Self> {
105 match prim {
106 1 => Some(Self::InvalidServiceName),
107 2 => Some(Self::InvalidInstanceName),
108 4 => Some(Self::AlreadyPublishedOnSubnet),
109 5 => Some(Self::InvalidMedia),
110 _ => None,
111 }
112 }
113
114 #[inline]
115 pub const fn into_primitive(self) -> u32 {
116 self as u32
117 }
118}
119
120#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
122#[repr(u32)]
123pub enum OnPublicationError {
124 DoNotRespond = 1,
126}
127
128impl OnPublicationError {
129 #[inline]
130 pub fn from_primitive(prim: u32) -> Option<Self> {
131 match prim {
132 1 => Some(Self::DoNotRespond),
133 _ => None,
134 }
135 }
136
137 #[inline]
138 pub const fn into_primitive(self) -> u32 {
139 self as u32
140 }
141}
142
143#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
145#[repr(u32)]
146pub enum PublicationCause {
147 Announcement = 1,
149 QueryMulticastResponse = 2,
152 QueryUnicastResponse = 3,
155}
156
157impl PublicationCause {
158 #[inline]
159 pub fn from_primitive(prim: u32) -> Option<Self> {
160 match prim {
161 1 => Some(Self::Announcement),
162 2 => Some(Self::QueryMulticastResponse),
163 3 => Some(Self::QueryUnicastResponse),
164 _ => None,
165 }
166 }
167
168 #[inline]
169 pub const fn into_primitive(self) -> u32 {
170 self as u32
171 }
172}
173
174#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
176pub enum PublishProxyHostError {
177 AlreadyPublishedLocally,
179 AlreadyPublishedOnSubnet,
182 #[doc(hidden)]
183 __SourceBreaking { unknown_ordinal: u32 },
184}
185
186#[macro_export]
188macro_rules! PublishProxyHostErrorUnknown {
189 () => {
190 _
191 };
192}
193
194impl PublishProxyHostError {
195 #[inline]
196 pub fn from_primitive(prim: u32) -> Option<Self> {
197 match prim {
198 1 => Some(Self::AlreadyPublishedLocally),
199 2 => Some(Self::AlreadyPublishedOnSubnet),
200 _ => None,
201 }
202 }
203
204 #[inline]
205 pub fn from_primitive_allow_unknown(prim: u32) -> Self {
206 match prim {
207 1 => Self::AlreadyPublishedLocally,
208 2 => Self::AlreadyPublishedOnSubnet,
209 unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
210 }
211 }
212
213 #[inline]
214 pub fn unknown() -> Self {
215 Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
216 }
217
218 #[inline]
219 pub const fn into_primitive(self) -> u32 {
220 match self {
221 Self::AlreadyPublishedLocally => 1,
222 Self::AlreadyPublishedOnSubnet => 2,
223 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
224 }
225 }
226
227 #[inline]
228 pub fn is_unknown(&self) -> bool {
229 match self {
230 Self::__SourceBreaking { unknown_ordinal: _ } => true,
231 _ => false,
232 }
233 }
234}
235
236#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
238#[repr(u32)]
239pub enum PublishServiceInstanceError {
240 AlreadyPublishedLocally = 1,
242 AlreadyPublishedOnSubnet = 2,
245}
246
247impl PublishServiceInstanceError {
248 #[inline]
249 pub fn from_primitive(prim: u32) -> Option<Self> {
250 match prim {
251 1 => Some(Self::AlreadyPublishedLocally),
252 2 => Some(Self::AlreadyPublishedOnSubnet),
253 _ => None,
254 }
255 }
256
257 #[inline]
258 pub const fn into_primitive(self) -> u32 {
259 self as u32
260 }
261}
262
263#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
265#[repr(u32)]
266pub enum ResourceType {
267 Ptr = 12,
269 Any = 255,
271}
272
273impl ResourceType {
274 #[inline]
275 pub fn from_primitive(prim: u32) -> Option<Self> {
276 match prim {
277 12 => Some(Self::Ptr),
278 255 => Some(Self::Any),
279 _ => None,
280 }
281 }
282
283 #[inline]
284 pub const fn into_primitive(self) -> u32 {
285 self as u32
286 }
287}
288
289#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
291#[repr(u32)]
292pub enum ServiceInstancePublicationCause {
293 Announcement = 1,
295 QueryMulticastResponse = 2,
298 QueryUnicastResponse = 3,
301}
302
303impl ServiceInstancePublicationCause {
304 #[inline]
305 pub fn from_primitive(prim: u32) -> Option<Self> {
306 match prim {
307 1 => Some(Self::Announcement),
308 2 => Some(Self::QueryMulticastResponse),
309 3 => Some(Self::QueryUnicastResponse),
310 _ => None,
311 }
312 }
313
314 #[inline]
315 pub const fn into_primitive(self) -> u32 {
316 self as u32
317 }
318}
319
320#[derive(Clone, Debug, PartialEq)]
323pub struct HostAddress {
324 pub address: fidl_fuchsia_net__common::IpAddress,
328 pub interface: u64,
332 pub ttl: i64,
335}
336
337impl fidl::Persistable for HostAddress {}
338
339#[derive(Clone, Debug, PartialEq)]
340pub struct HostNameResolverResolveHostNameRequest {
341 pub host: String,
342 pub timeout: i64,
343 pub options: HostNameResolutionOptions,
344}
345
346impl fidl::Persistable for HostNameResolverResolveHostNameRequest {}
347
348#[derive(Clone, Debug, PartialEq)]
349pub struct HostNameResolverResolveHostNameResponse {
350 pub addresses: Vec<HostAddress>,
351}
352
353impl fidl::Persistable for HostNameResolverResolveHostNameResponse {}
354
355#[derive(Clone, Debug, PartialEq)]
356pub struct HostNameSubscriptionListenerOnAddressesChangedRequest {
357 pub addresses: Vec<HostAddress>,
358}
359
360impl fidl::Persistable for HostNameSubscriptionListenerOnAddressesChangedRequest {}
361
362#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
368pub struct Publication {
369 pub port: u16,
371 pub text: Vec<String>,
373 pub srv_priority: u16,
376 pub srv_weight: u16,
379 pub ptr_ttl: i64,
381 pub srv_ttl: i64,
383 pub txt_ttl: i64,
385}
386
387impl fidl::Persistable for Publication {}
388
389#[derive(Clone, Debug, PartialEq)]
390pub struct PublicationResponderOnPublicationRequest {
391 pub publication_cause: PublicationCause,
392 pub subtype: Option<String>,
393 pub source_addresses: Vec<fidl_fuchsia_net__common::IpAddress>,
394}
395
396impl fidl::Persistable for PublicationResponderOnPublicationRequest {}
397
398#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
399pub struct PublicationResponderOnPublicationResponse {
400 pub publication: Option<Box<Publication>>,
401}
402
403impl fidl::Persistable for PublicationResponderOnPublicationResponse {}
404
405#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
406pub struct PublicationResponderSetSubtypesRequest {
407 pub subtypes: Vec<String>,
408}
409
410impl fidl::Persistable for PublicationResponderSetSubtypesRequest {}
411
412#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
413pub struct ResolverResolveHostNameRequest {
414 pub host: String,
415 pub timeout: i64,
416}
417
418impl fidl::Persistable for ResolverResolveHostNameRequest {}
419
420#[derive(Clone, Debug, PartialEq)]
421pub struct ResolverResolveHostNameResponse {
422 pub v4_address: Option<Box<fidl_fuchsia_net__common::Ipv4Address>>,
423 pub v6_address: Option<Box<fidl_fuchsia_net__common::Ipv6Address>>,
424}
425
426impl fidl::Persistable for ResolverResolveHostNameResponse {}
427
428#[derive(Clone, Debug, PartialEq)]
429pub struct ServiceInstancePublicationResponderOnPublicationRequest {
430 pub publication_cause: ServiceInstancePublicationCause,
431 pub subtype: Option<String>,
432 pub source_addresses: Vec<fidl_fuchsia_net__common::IpAddress>,
433}
434
435impl fidl::Persistable for ServiceInstancePublicationResponderOnPublicationRequest {}
436
437#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
438pub struct ServiceInstancePublicationResponderSetSubtypesRequest {
439 pub subtypes: Vec<String>,
440}
441
442impl fidl::Persistable for ServiceInstancePublicationResponderSetSubtypesRequest {}
443
444#[derive(Clone, Debug, PartialEq)]
445pub struct ServiceInstancePublicationResponderOnPublicationResponse {
446 pub publication: ServiceInstancePublication,
447}
448
449impl fidl::Persistable for ServiceInstancePublicationResponderOnPublicationResponse {}
450
451#[derive(Clone, Debug, PartialEq)]
452pub struct ServiceInstanceResolverResolveServiceInstanceRequest {
453 pub service: String,
454 pub instance: String,
455 pub timeout: i64,
456 pub options: ServiceInstanceResolutionOptions,
457}
458
459impl fidl::Persistable for ServiceInstanceResolverResolveServiceInstanceRequest {}
460
461#[derive(Clone, Debug, PartialEq)]
462pub struct ServiceInstanceResolverResolveServiceInstanceResponse {
463 pub instance: ServiceInstance,
464}
465
466impl fidl::Persistable for ServiceInstanceResolverResolveServiceInstanceResponse {}
467
468#[derive(Clone, Debug, PartialEq)]
469pub struct ServiceSubscriberOnInstanceChangedRequest {
470 pub instance: ServiceInstance,
471}
472
473impl fidl::Persistable for ServiceSubscriberOnInstanceChangedRequest {}
474
475#[derive(Clone, Debug, PartialEq)]
476pub struct ServiceSubscriberOnInstanceDiscoveredRequest {
477 pub instance: ServiceInstance,
478}
479
480impl fidl::Persistable for ServiceSubscriberOnInstanceDiscoveredRequest {}
481
482#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
483pub struct ServiceSubscriberOnInstanceLostRequest {
484 pub service: String,
485 pub instance: String,
486}
487
488impl fidl::Persistable for ServiceSubscriberOnInstanceLostRequest {}
489
490#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
491pub struct ServiceSubscriberOnQueryRequest {
492 pub resource_type: ResourceType,
493}
494
495impl fidl::Persistable for ServiceSubscriberOnQueryRequest {}
496
497#[derive(Clone, Debug, PartialEq)]
498pub struct ServiceSubscriptionListenerOnInstanceChangedRequest {
499 pub instance: ServiceInstance,
500}
501
502impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceChangedRequest {}
503
504#[derive(Clone, Debug, PartialEq)]
505pub struct ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
506 pub instance: ServiceInstance,
507}
508
509impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {}
510
511#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
512pub struct ServiceSubscriptionListenerOnInstanceLostRequest {
513 pub service: String,
514 pub instance: String,
515}
516
517impl fidl::Persistable for ServiceSubscriptionListenerOnInstanceLostRequest {}
518
519#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
520pub struct ServiceSubscriptionListenerOnQueryRequest {
521 pub resource_type: ResourceType,
522}
523
524impl fidl::Persistable for ServiceSubscriptionListenerOnQueryRequest {}
525
526#[derive(Clone, Debug, Default, PartialEq)]
528pub struct HostNameResolutionOptions {
529 pub media: Option<Media>,
532 pub ip_versions: Option<IpVersions>,
535 pub exclude_local: Option<bool>,
536 pub exclude_local_proxies: Option<bool>,
537 #[doc(hidden)]
538 pub __source_breaking: fidl::marker::SourceBreaking,
539}
540
541impl fidl::Persistable for HostNameResolutionOptions {}
542
543#[derive(Clone, Debug, Default, PartialEq)]
545pub struct HostNameSubscriptionOptions {
546 pub media: Option<Media>,
549 pub ip_versions: Option<IpVersions>,
552 pub exclude_local: Option<bool>,
553 pub exclude_local_proxies: Option<bool>,
554 #[doc(hidden)]
555 pub __source_breaking: fidl::marker::SourceBreaking,
556}
557
558impl fidl::Persistable for HostNameSubscriptionOptions {}
559
560#[derive(Clone, Debug, Default, PartialEq)]
562pub struct ProxyHostPublicationOptions {
563 pub media: Option<Media>,
567 pub ip_versions: Option<IpVersions>,
571 pub perform_probe: Option<bool>,
574 #[doc(hidden)]
575 pub __source_breaking: fidl::marker::SourceBreaking,
576}
577
578impl fidl::Persistable for ProxyHostPublicationOptions {}
579
580#[derive(Clone, Debug, Default, PartialEq)]
582pub struct ServiceInstance {
583 pub service: Option<String>,
585 pub instance: Option<String>,
587 pub ipv4_endpoint: Option<fidl_fuchsia_net__common::Ipv4SocketAddress>,
589 pub ipv6_endpoint: Option<fidl_fuchsia_net__common::Ipv6SocketAddress>,
591 pub text: Option<Vec<String>>,
593 pub srv_priority: Option<u16>,
596 pub srv_weight: Option<u16>,
599 pub target: Option<String>,
601 pub addresses: Option<Vec<fidl_fuchsia_net__common::SocketAddress>>,
603 pub text_strings: Option<Vec<Vec<u8>>>,
605 #[doc(hidden)]
606 pub __source_breaking: fidl::marker::SourceBreaking,
607}
608
609impl fidl::Persistable for ServiceInstance {}
610
611#[derive(Clone, Debug, Default, PartialEq)]
617pub struct ServiceInstancePublication {
618 pub port: Option<u16>,
620 pub text: Option<Vec<Vec<u8>>>,
623 pub srv_priority: Option<u16>,
627 pub srv_weight: Option<u16>,
631 pub ptr_ttl: Option<i64>,
634 pub srv_ttl: Option<i64>,
637 pub txt_ttl: Option<i64>,
640 #[doc(hidden)]
641 pub __source_breaking: fidl::marker::SourceBreaking,
642}
643
644impl fidl::Persistable for ServiceInstancePublication {}
645
646#[derive(Clone, Debug, Default, PartialEq)]
648pub struct ServiceInstancePublicationOptions {
649 pub media: Option<Media>,
655 pub ip_versions: Option<IpVersions>,
661 pub perform_probe: Option<bool>,
664 #[doc(hidden)]
665 pub __source_breaking: fidl::marker::SourceBreaking,
666}
667
668impl fidl::Persistable for ServiceInstancePublicationOptions {}
669
670#[derive(Clone, Debug, Default, PartialEq)]
672pub struct ServiceInstanceResolutionOptions {
673 pub media: Option<Media>,
676 pub ip_versions: Option<IpVersions>,
679 pub exclude_local: Option<bool>,
680 pub exclude_local_proxies: Option<bool>,
681 #[doc(hidden)]
682 pub __source_breaking: fidl::marker::SourceBreaking,
683}
684
685impl fidl::Persistable for ServiceInstanceResolutionOptions {}
686
687#[derive(Clone, Debug, Default, PartialEq)]
689pub struct ServiceSubscriptionOptions {
690 pub media: Option<Media>,
693 pub ip_versions: Option<IpVersions>,
696 pub exclude_local: Option<bool>,
697 pub exclude_local_proxies: Option<bool>,
698 #[doc(hidden)]
699 pub __source_breaking: fidl::marker::SourceBreaking,
700}
701
702impl fidl::Persistable for ServiceSubscriptionOptions {}
703
704pub mod host_name_resolver_ordinals {
705 pub const RESOLVE_HOST_NAME: u64 = 0x54f422692b53c46d;
706}
707
708pub mod host_name_subscriber_ordinals {
709 pub const SUBSCRIBE_TO_HOST_NAME: u64 = 0x23b6c5f4954f40ea;
710}
711
712pub mod host_name_subscription_listener_ordinals {
713 pub const ON_ADDRESSES_CHANGED: u64 = 0x44f5e70b2e8c1472;
714}
715
716pub mod proxy_host_publisher_ordinals {
717 pub const PUBLISH_PROXY_HOST: u64 = 0x639bfff950f973c2;
718}
719
720pub mod publication_responder__ordinals {
721 pub const ON_PUBLICATION: u64 = 0x71d805aee2907d06;
722 pub const SET_SUBTYPES: u64 = 0x5593e156370b19df;
723 pub const REANNOUNCE: u64 = 0x2550cc2a43aa838b;
724}
725
726pub mod publisher_ordinals {
727 pub const PUBLISH_SERVICE_INSTANCE: u64 = 0x3712171c42878797;
728}
729
730pub mod resolver_ordinals {
731 pub const RESOLVE_HOST_NAME: u64 = 0x3c8b2b50aad28e4a;
732}
733
734pub mod service_instance_publication_responder__ordinals {
735 pub const ON_PUBLICATION: u64 = 0x71753d79b12571ca;
736 pub const SET_SUBTYPES: u64 = 0x217fed6e404312a9;
737 pub const REANNOUNCE: u64 = 0x1b48d9ed30dce1a8;
738}
739
740pub mod service_instance_publisher_ordinals {
741 pub const PUBLISH_SERVICE_INSTANCE: u64 = 0x25d5fd0912cb5a9e;
742}
743
744pub mod service_instance_resolver_ordinals {
745 pub const RESOLVE_SERVICE_INSTANCE: u64 = 0x1a0d0c9fc6f2fd7;
746}
747
748pub mod service_subscriber_ordinals {
749 pub const ON_INSTANCE_DISCOVERED: u64 = 0x74aa039fd81dcab2;
750 pub const ON_INSTANCE_CHANGED: u64 = 0x24da258aad929434;
751 pub const ON_INSTANCE_LOST: u64 = 0x5beddb781791773f;
752 pub const ON_QUERY: u64 = 0x1d0496189fdb23f5;
753}
754
755pub mod service_subscriber2_ordinals {
756 pub const SUBSCRIBE_TO_SERVICE: u64 = 0x78f713d88dcf34aa;
757 pub const SUBSCRIBE_TO_ALL_SERVICES: u64 = 0x7c5192d46e380468;
758}
759
760pub mod service_subscription_listener_ordinals {
761 pub const ON_INSTANCE_DISCOVERED: u64 = 0x82f861e0b26a186;
762 pub const ON_INSTANCE_CHANGED: u64 = 0x7da325aa758d8929;
763 pub const ON_INSTANCE_LOST: u64 = 0x2ecb2f1600c5c6dc;
764 pub const ON_QUERY: u64 = 0x4f4eb8e3d10db611;
765}
766
767pub mod subscriber_ordinals {
768 pub const SUBSCRIBE_TO_SERVICE: u64 = 0x3a1a3b02c1809e3f;
769}
770
771mod internal {
772 use super::*;
773 unsafe impl fidl::encoding::TypeMarker for IpVersions {
774 type Owned = Self;
775
776 #[inline(always)]
777 fn inline_align(_context: fidl::encoding::Context) -> usize {
778 4
779 }
780
781 #[inline(always)]
782 fn inline_size(_context: fidl::encoding::Context) -> usize {
783 4
784 }
785 }
786
787 impl fidl::encoding::ValueTypeMarker for IpVersions {
788 type Borrowed<'a> = Self;
789 #[inline(always)]
790 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
791 *value
792 }
793 }
794
795 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IpVersions {
796 #[inline]
797 unsafe fn encode(
798 self,
799 encoder: &mut fidl::encoding::Encoder<'_, D>,
800 offset: usize,
801 _depth: fidl::encoding::Depth,
802 ) -> fidl::Result<()> {
803 encoder.debug_check_bounds::<Self>(offset);
804 if self.bits() & Self::all().bits() != self.bits() {
805 return Err(fidl::Error::InvalidBitsValue);
806 }
807 encoder.write_num(self.bits(), offset);
808 Ok(())
809 }
810 }
811
812 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpVersions {
813 #[inline(always)]
814 fn new_empty() -> Self {
815 Self::empty()
816 }
817
818 #[inline]
819 unsafe fn decode(
820 &mut self,
821 decoder: &mut fidl::encoding::Decoder<'_, D>,
822 offset: usize,
823 _depth: fidl::encoding::Depth,
824 ) -> fidl::Result<()> {
825 decoder.debug_check_bounds::<Self>(offset);
826 let prim = decoder.read_num::<u32>(offset);
827 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
828 Ok(())
829 }
830 }
831 unsafe impl fidl::encoding::TypeMarker for Media {
832 type Owned = Self;
833
834 #[inline(always)]
835 fn inline_align(_context: fidl::encoding::Context) -> usize {
836 4
837 }
838
839 #[inline(always)]
840 fn inline_size(_context: fidl::encoding::Context) -> usize {
841 4
842 }
843 }
844
845 impl fidl::encoding::ValueTypeMarker for Media {
846 type Borrowed<'a> = Self;
847 #[inline(always)]
848 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
849 *value
850 }
851 }
852
853 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Media {
854 #[inline]
855 unsafe fn encode(
856 self,
857 encoder: &mut fidl::encoding::Encoder<'_, D>,
858 offset: usize,
859 _depth: fidl::encoding::Depth,
860 ) -> fidl::Result<()> {
861 encoder.debug_check_bounds::<Self>(offset);
862 if self.bits() & Self::all().bits() != self.bits() {
863 return Err(fidl::Error::InvalidBitsValue);
864 }
865 encoder.write_num(self.bits(), offset);
866 Ok(())
867 }
868 }
869
870 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Media {
871 #[inline(always)]
872 fn new_empty() -> Self {
873 Self::empty()
874 }
875
876 #[inline]
877 unsafe fn decode(
878 &mut self,
879 decoder: &mut fidl::encoding::Decoder<'_, D>,
880 offset: usize,
881 _depth: fidl::encoding::Depth,
882 ) -> fidl::Result<()> {
883 decoder.debug_check_bounds::<Self>(offset);
884 let prim = decoder.read_num::<u32>(offset);
885 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
886 Ok(())
887 }
888 }
889 unsafe impl fidl::encoding::TypeMarker for Error {
890 type Owned = Self;
891
892 #[inline(always)]
893 fn inline_align(_context: fidl::encoding::Context) -> usize {
894 std::mem::align_of::<u32>()
895 }
896
897 #[inline(always)]
898 fn inline_size(_context: fidl::encoding::Context) -> usize {
899 std::mem::size_of::<u32>()
900 }
901
902 #[inline(always)]
903 fn encode_is_copy() -> bool {
904 true
905 }
906
907 #[inline(always)]
908 fn decode_is_copy() -> bool {
909 false
910 }
911 }
912
913 impl fidl::encoding::ValueTypeMarker for Error {
914 type Borrowed<'a> = Self;
915 #[inline(always)]
916 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
917 *value
918 }
919 }
920
921 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
922 #[inline]
923 unsafe fn encode(
924 self,
925 encoder: &mut fidl::encoding::Encoder<'_, D>,
926 offset: usize,
927 _depth: fidl::encoding::Depth,
928 ) -> fidl::Result<()> {
929 encoder.debug_check_bounds::<Self>(offset);
930 encoder.write_num(self.into_primitive(), offset);
931 Ok(())
932 }
933 }
934
935 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
936 #[inline(always)]
937 fn new_empty() -> Self {
938 Self::InvalidServiceName
939 }
940
941 #[inline]
942 unsafe fn decode(
943 &mut self,
944 decoder: &mut fidl::encoding::Decoder<'_, D>,
945 offset: usize,
946 _depth: fidl::encoding::Depth,
947 ) -> fidl::Result<()> {
948 decoder.debug_check_bounds::<Self>(offset);
949 let prim = decoder.read_num::<u32>(offset);
950
951 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
952 Ok(())
953 }
954 }
955 unsafe impl fidl::encoding::TypeMarker for OnPublicationError {
956 type Owned = Self;
957
958 #[inline(always)]
959 fn inline_align(_context: fidl::encoding::Context) -> usize {
960 std::mem::align_of::<u32>()
961 }
962
963 #[inline(always)]
964 fn inline_size(_context: fidl::encoding::Context) -> usize {
965 std::mem::size_of::<u32>()
966 }
967
968 #[inline(always)]
969 fn encode_is_copy() -> bool {
970 true
971 }
972
973 #[inline(always)]
974 fn decode_is_copy() -> bool {
975 false
976 }
977 }
978
979 impl fidl::encoding::ValueTypeMarker for OnPublicationError {
980 type Borrowed<'a> = Self;
981 #[inline(always)]
982 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
983 *value
984 }
985 }
986
987 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
988 for OnPublicationError
989 {
990 #[inline]
991 unsafe fn encode(
992 self,
993 encoder: &mut fidl::encoding::Encoder<'_, D>,
994 offset: usize,
995 _depth: fidl::encoding::Depth,
996 ) -> fidl::Result<()> {
997 encoder.debug_check_bounds::<Self>(offset);
998 encoder.write_num(self.into_primitive(), offset);
999 Ok(())
1000 }
1001 }
1002
1003 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnPublicationError {
1004 #[inline(always)]
1005 fn new_empty() -> Self {
1006 Self::DoNotRespond
1007 }
1008
1009 #[inline]
1010 unsafe fn decode(
1011 &mut self,
1012 decoder: &mut fidl::encoding::Decoder<'_, D>,
1013 offset: usize,
1014 _depth: fidl::encoding::Depth,
1015 ) -> fidl::Result<()> {
1016 decoder.debug_check_bounds::<Self>(offset);
1017 let prim = decoder.read_num::<u32>(offset);
1018
1019 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1020 Ok(())
1021 }
1022 }
1023 unsafe impl fidl::encoding::TypeMarker for PublicationCause {
1024 type Owned = Self;
1025
1026 #[inline(always)]
1027 fn inline_align(_context: fidl::encoding::Context) -> usize {
1028 std::mem::align_of::<u32>()
1029 }
1030
1031 #[inline(always)]
1032 fn inline_size(_context: fidl::encoding::Context) -> usize {
1033 std::mem::size_of::<u32>()
1034 }
1035
1036 #[inline(always)]
1037 fn encode_is_copy() -> bool {
1038 true
1039 }
1040
1041 #[inline(always)]
1042 fn decode_is_copy() -> bool {
1043 false
1044 }
1045 }
1046
1047 impl fidl::encoding::ValueTypeMarker for PublicationCause {
1048 type Borrowed<'a> = Self;
1049 #[inline(always)]
1050 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1051 *value
1052 }
1053 }
1054
1055 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1056 for PublicationCause
1057 {
1058 #[inline]
1059 unsafe fn encode(
1060 self,
1061 encoder: &mut fidl::encoding::Encoder<'_, D>,
1062 offset: usize,
1063 _depth: fidl::encoding::Depth,
1064 ) -> fidl::Result<()> {
1065 encoder.debug_check_bounds::<Self>(offset);
1066 encoder.write_num(self.into_primitive(), offset);
1067 Ok(())
1068 }
1069 }
1070
1071 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublicationCause {
1072 #[inline(always)]
1073 fn new_empty() -> Self {
1074 Self::Announcement
1075 }
1076
1077 #[inline]
1078 unsafe fn decode(
1079 &mut self,
1080 decoder: &mut fidl::encoding::Decoder<'_, D>,
1081 offset: usize,
1082 _depth: fidl::encoding::Depth,
1083 ) -> fidl::Result<()> {
1084 decoder.debug_check_bounds::<Self>(offset);
1085 let prim = decoder.read_num::<u32>(offset);
1086
1087 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1088 Ok(())
1089 }
1090 }
1091 unsafe impl fidl::encoding::TypeMarker for PublishProxyHostError {
1092 type Owned = Self;
1093
1094 #[inline(always)]
1095 fn inline_align(_context: fidl::encoding::Context) -> usize {
1096 std::mem::align_of::<u32>()
1097 }
1098
1099 #[inline(always)]
1100 fn inline_size(_context: fidl::encoding::Context) -> usize {
1101 std::mem::size_of::<u32>()
1102 }
1103
1104 #[inline(always)]
1105 fn encode_is_copy() -> bool {
1106 false
1107 }
1108
1109 #[inline(always)]
1110 fn decode_is_copy() -> bool {
1111 false
1112 }
1113 }
1114
1115 impl fidl::encoding::ValueTypeMarker for PublishProxyHostError {
1116 type Borrowed<'a> = Self;
1117 #[inline(always)]
1118 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1119 *value
1120 }
1121 }
1122
1123 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1124 for PublishProxyHostError
1125 {
1126 #[inline]
1127 unsafe fn encode(
1128 self,
1129 encoder: &mut fidl::encoding::Encoder<'_, D>,
1130 offset: usize,
1131 _depth: fidl::encoding::Depth,
1132 ) -> fidl::Result<()> {
1133 encoder.debug_check_bounds::<Self>(offset);
1134 encoder.write_num(self.into_primitive(), offset);
1135 Ok(())
1136 }
1137 }
1138
1139 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublishProxyHostError {
1140 #[inline(always)]
1141 fn new_empty() -> Self {
1142 Self::unknown()
1143 }
1144
1145 #[inline]
1146 unsafe fn decode(
1147 &mut self,
1148 decoder: &mut fidl::encoding::Decoder<'_, D>,
1149 offset: usize,
1150 _depth: fidl::encoding::Depth,
1151 ) -> fidl::Result<()> {
1152 decoder.debug_check_bounds::<Self>(offset);
1153 let prim = decoder.read_num::<u32>(offset);
1154
1155 *self = Self::from_primitive_allow_unknown(prim);
1156 Ok(())
1157 }
1158 }
1159 unsafe impl fidl::encoding::TypeMarker for PublishServiceInstanceError {
1160 type Owned = Self;
1161
1162 #[inline(always)]
1163 fn inline_align(_context: fidl::encoding::Context) -> usize {
1164 std::mem::align_of::<u32>()
1165 }
1166
1167 #[inline(always)]
1168 fn inline_size(_context: fidl::encoding::Context) -> usize {
1169 std::mem::size_of::<u32>()
1170 }
1171
1172 #[inline(always)]
1173 fn encode_is_copy() -> bool {
1174 true
1175 }
1176
1177 #[inline(always)]
1178 fn decode_is_copy() -> bool {
1179 false
1180 }
1181 }
1182
1183 impl fidl::encoding::ValueTypeMarker for PublishServiceInstanceError {
1184 type Borrowed<'a> = Self;
1185 #[inline(always)]
1186 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1187 *value
1188 }
1189 }
1190
1191 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1192 for PublishServiceInstanceError
1193 {
1194 #[inline]
1195 unsafe fn encode(
1196 self,
1197 encoder: &mut fidl::encoding::Encoder<'_, D>,
1198 offset: usize,
1199 _depth: fidl::encoding::Depth,
1200 ) -> fidl::Result<()> {
1201 encoder.debug_check_bounds::<Self>(offset);
1202 encoder.write_num(self.into_primitive(), offset);
1203 Ok(())
1204 }
1205 }
1206
1207 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1208 for PublishServiceInstanceError
1209 {
1210 #[inline(always)]
1211 fn new_empty() -> Self {
1212 Self::AlreadyPublishedLocally
1213 }
1214
1215 #[inline]
1216 unsafe fn decode(
1217 &mut self,
1218 decoder: &mut fidl::encoding::Decoder<'_, D>,
1219 offset: usize,
1220 _depth: fidl::encoding::Depth,
1221 ) -> fidl::Result<()> {
1222 decoder.debug_check_bounds::<Self>(offset);
1223 let prim = decoder.read_num::<u32>(offset);
1224
1225 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1226 Ok(())
1227 }
1228 }
1229 unsafe impl fidl::encoding::TypeMarker for ResourceType {
1230 type Owned = Self;
1231
1232 #[inline(always)]
1233 fn inline_align(_context: fidl::encoding::Context) -> usize {
1234 std::mem::align_of::<u32>()
1235 }
1236
1237 #[inline(always)]
1238 fn inline_size(_context: fidl::encoding::Context) -> usize {
1239 std::mem::size_of::<u32>()
1240 }
1241
1242 #[inline(always)]
1243 fn encode_is_copy() -> bool {
1244 true
1245 }
1246
1247 #[inline(always)]
1248 fn decode_is_copy() -> bool {
1249 false
1250 }
1251 }
1252
1253 impl fidl::encoding::ValueTypeMarker for ResourceType {
1254 type Borrowed<'a> = Self;
1255 #[inline(always)]
1256 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1257 *value
1258 }
1259 }
1260
1261 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResourceType {
1262 #[inline]
1263 unsafe fn encode(
1264 self,
1265 encoder: &mut fidl::encoding::Encoder<'_, D>,
1266 offset: usize,
1267 _depth: fidl::encoding::Depth,
1268 ) -> fidl::Result<()> {
1269 encoder.debug_check_bounds::<Self>(offset);
1270 encoder.write_num(self.into_primitive(), offset);
1271 Ok(())
1272 }
1273 }
1274
1275 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResourceType {
1276 #[inline(always)]
1277 fn new_empty() -> Self {
1278 Self::Ptr
1279 }
1280
1281 #[inline]
1282 unsafe fn decode(
1283 &mut self,
1284 decoder: &mut fidl::encoding::Decoder<'_, D>,
1285 offset: usize,
1286 _depth: fidl::encoding::Depth,
1287 ) -> fidl::Result<()> {
1288 decoder.debug_check_bounds::<Self>(offset);
1289 let prim = decoder.read_num::<u32>(offset);
1290
1291 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1292 Ok(())
1293 }
1294 }
1295 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationCause {
1296 type Owned = Self;
1297
1298 #[inline(always)]
1299 fn inline_align(_context: fidl::encoding::Context) -> usize {
1300 std::mem::align_of::<u32>()
1301 }
1302
1303 #[inline(always)]
1304 fn inline_size(_context: fidl::encoding::Context) -> usize {
1305 std::mem::size_of::<u32>()
1306 }
1307
1308 #[inline(always)]
1309 fn encode_is_copy() -> bool {
1310 true
1311 }
1312
1313 #[inline(always)]
1314 fn decode_is_copy() -> bool {
1315 false
1316 }
1317 }
1318
1319 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationCause {
1320 type Borrowed<'a> = Self;
1321 #[inline(always)]
1322 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1323 *value
1324 }
1325 }
1326
1327 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1328 for ServiceInstancePublicationCause
1329 {
1330 #[inline]
1331 unsafe fn encode(
1332 self,
1333 encoder: &mut fidl::encoding::Encoder<'_, D>,
1334 offset: usize,
1335 _depth: fidl::encoding::Depth,
1336 ) -> fidl::Result<()> {
1337 encoder.debug_check_bounds::<Self>(offset);
1338 encoder.write_num(self.into_primitive(), offset);
1339 Ok(())
1340 }
1341 }
1342
1343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1344 for ServiceInstancePublicationCause
1345 {
1346 #[inline(always)]
1347 fn new_empty() -> Self {
1348 Self::Announcement
1349 }
1350
1351 #[inline]
1352 unsafe fn decode(
1353 &mut self,
1354 decoder: &mut fidl::encoding::Decoder<'_, D>,
1355 offset: usize,
1356 _depth: fidl::encoding::Depth,
1357 ) -> fidl::Result<()> {
1358 decoder.debug_check_bounds::<Self>(offset);
1359 let prim = decoder.read_num::<u32>(offset);
1360
1361 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1362 Ok(())
1363 }
1364 }
1365
1366 impl fidl::encoding::ValueTypeMarker for HostAddress {
1367 type Borrowed<'a> = &'a Self;
1368 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1369 value
1370 }
1371 }
1372
1373 unsafe impl fidl::encoding::TypeMarker for HostAddress {
1374 type Owned = Self;
1375
1376 #[inline(always)]
1377 fn inline_align(_context: fidl::encoding::Context) -> usize {
1378 8
1379 }
1380
1381 #[inline(always)]
1382 fn inline_size(_context: fidl::encoding::Context) -> usize {
1383 32
1384 }
1385 }
1386
1387 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HostAddress, D>
1388 for &HostAddress
1389 {
1390 #[inline]
1391 unsafe fn encode(
1392 self,
1393 encoder: &mut fidl::encoding::Encoder<'_, D>,
1394 offset: usize,
1395 _depth: fidl::encoding::Depth,
1396 ) -> fidl::Result<()> {
1397 encoder.debug_check_bounds::<HostAddress>(offset);
1398 fidl::encoding::Encode::<HostAddress, D>::encode(
1400 (
1401 <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1402 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface),
1403 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ttl),
1404 ),
1405 encoder, offset, _depth
1406 )
1407 }
1408 }
1409 unsafe impl<
1410 D: fidl::encoding::ResourceDialect,
1411 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
1412 T1: fidl::encoding::Encode<u64, D>,
1413 T2: fidl::encoding::Encode<i64, D>,
1414 > fidl::encoding::Encode<HostAddress, D> for (T0, T1, T2)
1415 {
1416 #[inline]
1417 unsafe fn encode(
1418 self,
1419 encoder: &mut fidl::encoding::Encoder<'_, D>,
1420 offset: usize,
1421 depth: fidl::encoding::Depth,
1422 ) -> fidl::Result<()> {
1423 encoder.debug_check_bounds::<HostAddress>(offset);
1424 self.0.encode(encoder, offset + 0, depth)?;
1428 self.1.encode(encoder, offset + 16, depth)?;
1429 self.2.encode(encoder, offset + 24, depth)?;
1430 Ok(())
1431 }
1432 }
1433
1434 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HostAddress {
1435 #[inline(always)]
1436 fn new_empty() -> Self {
1437 Self {
1438 address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
1439 interface: fidl::new_empty!(u64, D),
1440 ttl: fidl::new_empty!(i64, D),
1441 }
1442 }
1443
1444 #[inline]
1445 unsafe fn decode(
1446 &mut self,
1447 decoder: &mut fidl::encoding::Decoder<'_, D>,
1448 offset: usize,
1449 _depth: fidl::encoding::Depth,
1450 ) -> fidl::Result<()> {
1451 decoder.debug_check_bounds::<Self>(offset);
1452 fidl::decode!(
1454 fidl_fuchsia_net__common::IpAddress,
1455 D,
1456 &mut self.address,
1457 decoder,
1458 offset + 0,
1459 _depth
1460 )?;
1461 fidl::decode!(u64, D, &mut self.interface, decoder, offset + 16, _depth)?;
1462 fidl::decode!(i64, D, &mut self.ttl, decoder, offset + 24, _depth)?;
1463 Ok(())
1464 }
1465 }
1466
1467 impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameRequest {
1468 type Borrowed<'a> = &'a Self;
1469 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1470 value
1471 }
1472 }
1473
1474 unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameRequest {
1475 type Owned = Self;
1476
1477 #[inline(always)]
1478 fn inline_align(_context: fidl::encoding::Context) -> usize {
1479 8
1480 }
1481
1482 #[inline(always)]
1483 fn inline_size(_context: fidl::encoding::Context) -> usize {
1484 40
1485 }
1486 }
1487
1488 unsafe impl<D: fidl::encoding::ResourceDialect>
1489 fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D>
1490 for &HostNameResolverResolveHostNameRequest
1491 {
1492 #[inline]
1493 unsafe fn encode(
1494 self,
1495 encoder: &mut fidl::encoding::Encoder<'_, D>,
1496 offset: usize,
1497 _depth: fidl::encoding::Depth,
1498 ) -> fidl::Result<()> {
1499 encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1500 fidl::encoding::Encode::<HostNameResolverResolveHostNameRequest, D>::encode(
1502 (
1503 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1504 &self.host,
1505 ),
1506 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
1507 <HostNameResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(
1508 &self.options,
1509 ),
1510 ),
1511 encoder,
1512 offset,
1513 _depth,
1514 )
1515 }
1516 }
1517 unsafe impl<
1518 D: fidl::encoding::ResourceDialect,
1519 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1520 T1: fidl::encoding::Encode<i64, D>,
1521 T2: fidl::encoding::Encode<HostNameResolutionOptions, D>,
1522 > fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D> for (T0, T1, T2)
1523 {
1524 #[inline]
1525 unsafe fn encode(
1526 self,
1527 encoder: &mut fidl::encoding::Encoder<'_, D>,
1528 offset: usize,
1529 depth: fidl::encoding::Depth,
1530 ) -> fidl::Result<()> {
1531 encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1532 self.0.encode(encoder, offset + 0, depth)?;
1536 self.1.encode(encoder, offset + 16, depth)?;
1537 self.2.encode(encoder, offset + 24, depth)?;
1538 Ok(())
1539 }
1540 }
1541
1542 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1543 for HostNameResolverResolveHostNameRequest
1544 {
1545 #[inline(always)]
1546 fn new_empty() -> Self {
1547 Self {
1548 host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
1549 timeout: fidl::new_empty!(i64, D),
1550 options: fidl::new_empty!(HostNameResolutionOptions, D),
1551 }
1552 }
1553
1554 #[inline]
1555 unsafe fn decode(
1556 &mut self,
1557 decoder: &mut fidl::encoding::Decoder<'_, D>,
1558 offset: usize,
1559 _depth: fidl::encoding::Depth,
1560 ) -> fidl::Result<()> {
1561 decoder.debug_check_bounds::<Self>(offset);
1562 fidl::decode!(
1564 fidl::encoding::BoundedString<255>,
1565 D,
1566 &mut self.host,
1567 decoder,
1568 offset + 0,
1569 _depth
1570 )?;
1571 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
1572 fidl::decode!(
1573 HostNameResolutionOptions,
1574 D,
1575 &mut self.options,
1576 decoder,
1577 offset + 24,
1578 _depth
1579 )?;
1580 Ok(())
1581 }
1582 }
1583
1584 impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameResponse {
1585 type Borrowed<'a> = &'a Self;
1586 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1587 value
1588 }
1589 }
1590
1591 unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameResponse {
1592 type Owned = Self;
1593
1594 #[inline(always)]
1595 fn inline_align(_context: fidl::encoding::Context) -> usize {
1596 8
1597 }
1598
1599 #[inline(always)]
1600 fn inline_size(_context: fidl::encoding::Context) -> usize {
1601 16
1602 }
1603 }
1604
1605 unsafe impl<D: fidl::encoding::ResourceDialect>
1606 fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D>
1607 for &HostNameResolverResolveHostNameResponse
1608 {
1609 #[inline]
1610 unsafe fn encode(
1611 self,
1612 encoder: &mut fidl::encoding::Encoder<'_, D>,
1613 offset: usize,
1614 _depth: fidl::encoding::Depth,
1615 ) -> fidl::Result<()> {
1616 encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1617 fidl::encoding::Encode::<HostNameResolverResolveHostNameResponse, D>::encode(
1619 (
1620 <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1621 ),
1622 encoder, offset, _depth
1623 )
1624 }
1625 }
1626 unsafe impl<
1627 D: fidl::encoding::ResourceDialect,
1628 T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1629 > fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D> for (T0,)
1630 {
1631 #[inline]
1632 unsafe fn encode(
1633 self,
1634 encoder: &mut fidl::encoding::Encoder<'_, D>,
1635 offset: usize,
1636 depth: fidl::encoding::Depth,
1637 ) -> fidl::Result<()> {
1638 encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1639 self.0.encode(encoder, offset + 0, depth)?;
1643 Ok(())
1644 }
1645 }
1646
1647 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1648 for HostNameResolverResolveHostNameResponse
1649 {
1650 #[inline(always)]
1651 fn new_empty() -> Self {
1652 Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1653 }
1654
1655 #[inline]
1656 unsafe fn decode(
1657 &mut self,
1658 decoder: &mut fidl::encoding::Decoder<'_, D>,
1659 offset: usize,
1660 _depth: fidl::encoding::Depth,
1661 ) -> fidl::Result<()> {
1662 decoder.debug_check_bounds::<Self>(offset);
1663 fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1665 Ok(())
1666 }
1667 }
1668
1669 impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1670 type Borrowed<'a> = &'a Self;
1671 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1672 value
1673 }
1674 }
1675
1676 unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1677 type Owned = Self;
1678
1679 #[inline(always)]
1680 fn inline_align(_context: fidl::encoding::Context) -> usize {
1681 8
1682 }
1683
1684 #[inline(always)]
1685 fn inline_size(_context: fidl::encoding::Context) -> usize {
1686 16
1687 }
1688 }
1689
1690 unsafe impl<D: fidl::encoding::ResourceDialect>
1691 fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1692 for &HostNameSubscriptionListenerOnAddressesChangedRequest
1693 {
1694 #[inline]
1695 unsafe fn encode(
1696 self,
1697 encoder: &mut fidl::encoding::Encoder<'_, D>,
1698 offset: usize,
1699 _depth: fidl::encoding::Depth,
1700 ) -> fidl::Result<()> {
1701 encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1702 offset,
1703 );
1704 fidl::encoding::Encode::<HostNameSubscriptionListenerOnAddressesChangedRequest, D>::encode(
1706 (
1707 <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1708 ),
1709 encoder, offset, _depth
1710 )
1711 }
1712 }
1713 unsafe impl<
1714 D: fidl::encoding::ResourceDialect,
1715 T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1716 > fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1717 for (T0,)
1718 {
1719 #[inline]
1720 unsafe fn encode(
1721 self,
1722 encoder: &mut fidl::encoding::Encoder<'_, D>,
1723 offset: usize,
1724 depth: fidl::encoding::Depth,
1725 ) -> fidl::Result<()> {
1726 encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1727 offset,
1728 );
1729 self.0.encode(encoder, offset + 0, depth)?;
1733 Ok(())
1734 }
1735 }
1736
1737 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1738 for HostNameSubscriptionListenerOnAddressesChangedRequest
1739 {
1740 #[inline(always)]
1741 fn new_empty() -> Self {
1742 Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1743 }
1744
1745 #[inline]
1746 unsafe fn decode(
1747 &mut self,
1748 decoder: &mut fidl::encoding::Decoder<'_, D>,
1749 offset: usize,
1750 _depth: fidl::encoding::Depth,
1751 ) -> fidl::Result<()> {
1752 decoder.debug_check_bounds::<Self>(offset);
1753 fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1755 Ok(())
1756 }
1757 }
1758
1759 impl fidl::encoding::ValueTypeMarker for Publication {
1760 type Borrowed<'a> = &'a Self;
1761 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1762 value
1763 }
1764 }
1765
1766 unsafe impl fidl::encoding::TypeMarker for Publication {
1767 type Owned = Self;
1768
1769 #[inline(always)]
1770 fn inline_align(_context: fidl::encoding::Context) -> usize {
1771 8
1772 }
1773
1774 #[inline(always)]
1775 fn inline_size(_context: fidl::encoding::Context) -> usize {
1776 56
1777 }
1778 }
1779
1780 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Publication, D>
1781 for &Publication
1782 {
1783 #[inline]
1784 unsafe fn encode(
1785 self,
1786 encoder: &mut fidl::encoding::Encoder<'_, D>,
1787 offset: usize,
1788 _depth: fidl::encoding::Depth,
1789 ) -> fidl::Result<()> {
1790 encoder.debug_check_bounds::<Publication>(offset);
1791 fidl::encoding::Encode::<Publication, D>::encode(
1793 (
1794 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.port),
1795 <fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.text),
1796 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_priority),
1797 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_weight),
1798 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ptr_ttl),
1799 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_ttl),
1800 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txt_ttl),
1801 ),
1802 encoder, offset, _depth
1803 )
1804 }
1805 }
1806 unsafe impl<
1807 D: fidl::encoding::ResourceDialect,
1808 T0: fidl::encoding::Encode<u16, D>,
1809 T1: fidl::encoding::Encode<
1810 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1811 D,
1812 >,
1813 T2: fidl::encoding::Encode<u16, D>,
1814 T3: fidl::encoding::Encode<u16, D>,
1815 T4: fidl::encoding::Encode<i64, D>,
1816 T5: fidl::encoding::Encode<i64, D>,
1817 T6: fidl::encoding::Encode<i64, D>,
1818 > fidl::encoding::Encode<Publication, D> for (T0, T1, T2, T3, T4, T5, T6)
1819 {
1820 #[inline]
1821 unsafe fn encode(
1822 self,
1823 encoder: &mut fidl::encoding::Encoder<'_, D>,
1824 offset: usize,
1825 depth: fidl::encoding::Depth,
1826 ) -> fidl::Result<()> {
1827 encoder.debug_check_bounds::<Publication>(offset);
1828 unsafe {
1831 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1832 (ptr as *mut u64).write_unaligned(0);
1833 }
1834 unsafe {
1835 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
1836 (ptr as *mut u64).write_unaligned(0);
1837 }
1838 self.0.encode(encoder, offset + 0, depth)?;
1840 self.1.encode(encoder, offset + 8, depth)?;
1841 self.2.encode(encoder, offset + 24, depth)?;
1842 self.3.encode(encoder, offset + 26, depth)?;
1843 self.4.encode(encoder, offset + 32, depth)?;
1844 self.5.encode(encoder, offset + 40, depth)?;
1845 self.6.encode(encoder, offset + 48, depth)?;
1846 Ok(())
1847 }
1848 }
1849
1850 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Publication {
1851 #[inline(always)]
1852 fn new_empty() -> Self {
1853 Self {
1854 port: fidl::new_empty!(u16, D),
1855 text: fidl::new_empty!(
1856 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1857 D
1858 ),
1859 srv_priority: fidl::new_empty!(u16, D),
1860 srv_weight: fidl::new_empty!(u16, D),
1861 ptr_ttl: fidl::new_empty!(i64, D),
1862 srv_ttl: fidl::new_empty!(i64, D),
1863 txt_ttl: fidl::new_empty!(i64, D),
1864 }
1865 }
1866
1867 #[inline]
1868 unsafe fn decode(
1869 &mut self,
1870 decoder: &mut fidl::encoding::Decoder<'_, D>,
1871 offset: usize,
1872 _depth: fidl::encoding::Depth,
1873 ) -> fidl::Result<()> {
1874 decoder.debug_check_bounds::<Self>(offset);
1875 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1877 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1878 let mask = 0xffffffffffff0000u64;
1879 let maskedval = padval & mask;
1880 if maskedval != 0 {
1881 return Err(fidl::Error::NonZeroPadding {
1882 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1883 });
1884 }
1885 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
1886 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1887 let mask = 0xffffffff00000000u64;
1888 let maskedval = padval & mask;
1889 if maskedval != 0 {
1890 return Err(fidl::Error::NonZeroPadding {
1891 padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
1892 });
1893 }
1894 fidl::decode!(u16, D, &mut self.port, decoder, offset + 0, _depth)?;
1895 fidl::decode!(
1896 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1897 D,
1898 &mut self.text,
1899 decoder,
1900 offset + 8,
1901 _depth
1902 )?;
1903 fidl::decode!(u16, D, &mut self.srv_priority, decoder, offset + 24, _depth)?;
1904 fidl::decode!(u16, D, &mut self.srv_weight, decoder, offset + 26, _depth)?;
1905 fidl::decode!(i64, D, &mut self.ptr_ttl, decoder, offset + 32, _depth)?;
1906 fidl::decode!(i64, D, &mut self.srv_ttl, decoder, offset + 40, _depth)?;
1907 fidl::decode!(i64, D, &mut self.txt_ttl, decoder, offset + 48, _depth)?;
1908 Ok(())
1909 }
1910 }
1911
1912 impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationRequest {
1913 type Borrowed<'a> = &'a Self;
1914 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1915 value
1916 }
1917 }
1918
1919 unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationRequest {
1920 type Owned = Self;
1921
1922 #[inline(always)]
1923 fn inline_align(_context: fidl::encoding::Context) -> usize {
1924 8
1925 }
1926
1927 #[inline(always)]
1928 fn inline_size(_context: fidl::encoding::Context) -> usize {
1929 40
1930 }
1931 }
1932
1933 unsafe impl<D: fidl::encoding::ResourceDialect>
1934 fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D>
1935 for &PublicationResponderOnPublicationRequest
1936 {
1937 #[inline]
1938 unsafe fn encode(
1939 self,
1940 encoder: &mut fidl::encoding::Encoder<'_, D>,
1941 offset: usize,
1942 _depth: fidl::encoding::Depth,
1943 ) -> fidl::Result<()> {
1944 encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1945 fidl::encoding::Encode::<PublicationResponderOnPublicationRequest, D>::encode(
1947 (
1948 <PublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
1949 <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
1950 <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
1951 ),
1952 encoder, offset, _depth
1953 )
1954 }
1955 }
1956 unsafe impl<
1957 D: fidl::encoding::ResourceDialect,
1958 T0: fidl::encoding::Encode<PublicationCause, D>,
1959 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
1960 T2: fidl::encoding::Encode<
1961 fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
1962 D,
1963 >,
1964 > fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D> for (T0, T1, T2)
1965 {
1966 #[inline]
1967 unsafe fn encode(
1968 self,
1969 encoder: &mut fidl::encoding::Encoder<'_, D>,
1970 offset: usize,
1971 depth: fidl::encoding::Depth,
1972 ) -> fidl::Result<()> {
1973 encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1974 unsafe {
1977 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1978 (ptr as *mut u64).write_unaligned(0);
1979 }
1980 self.0.encode(encoder, offset + 0, depth)?;
1982 self.1.encode(encoder, offset + 8, depth)?;
1983 self.2.encode(encoder, offset + 24, depth)?;
1984 Ok(())
1985 }
1986 }
1987
1988 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1989 for PublicationResponderOnPublicationRequest
1990 {
1991 #[inline(always)]
1992 fn new_empty() -> Self {
1993 Self {
1994 publication_cause: fidl::new_empty!(PublicationCause, D),
1995 subtype: fidl::new_empty!(
1996 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
1997 D
1998 ),
1999 source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
2000 }
2001 }
2002
2003 #[inline]
2004 unsafe fn decode(
2005 &mut self,
2006 decoder: &mut fidl::encoding::Decoder<'_, D>,
2007 offset: usize,
2008 _depth: fidl::encoding::Depth,
2009 ) -> fidl::Result<()> {
2010 decoder.debug_check_bounds::<Self>(offset);
2011 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2013 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2014 let mask = 0xffffffff00000000u64;
2015 let maskedval = padval & mask;
2016 if maskedval != 0 {
2017 return Err(fidl::Error::NonZeroPadding {
2018 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2019 });
2020 }
2021 fidl::decode!(
2022 PublicationCause,
2023 D,
2024 &mut self.publication_cause,
2025 decoder,
2026 offset + 0,
2027 _depth
2028 )?;
2029 fidl::decode!(
2030 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2031 D,
2032 &mut self.subtype,
2033 decoder,
2034 offset + 8,
2035 _depth
2036 )?;
2037 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
2038 Ok(())
2039 }
2040 }
2041
2042 impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationResponse {
2043 type Borrowed<'a> = &'a Self;
2044 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2045 value
2046 }
2047 }
2048
2049 unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationResponse {
2050 type Owned = Self;
2051
2052 #[inline(always)]
2053 fn inline_align(_context: fidl::encoding::Context) -> usize {
2054 8
2055 }
2056
2057 #[inline(always)]
2058 fn inline_size(_context: fidl::encoding::Context) -> usize {
2059 8
2060 }
2061 }
2062
2063 unsafe impl<D: fidl::encoding::ResourceDialect>
2064 fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D>
2065 for &PublicationResponderOnPublicationResponse
2066 {
2067 #[inline]
2068 unsafe fn encode(
2069 self,
2070 encoder: &mut fidl::encoding::Encoder<'_, D>,
2071 offset: usize,
2072 _depth: fidl::encoding::Depth,
2073 ) -> fidl::Result<()> {
2074 encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2075 fidl::encoding::Encode::<PublicationResponderOnPublicationResponse, D>::encode(
2077 (<fidl::encoding::Boxed<Publication> as fidl::encoding::ValueTypeMarker>::borrow(
2078 &self.publication,
2079 ),),
2080 encoder,
2081 offset,
2082 _depth,
2083 )
2084 }
2085 }
2086 unsafe impl<
2087 D: fidl::encoding::ResourceDialect,
2088 T0: fidl::encoding::Encode<fidl::encoding::Boxed<Publication>, D>,
2089 > fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D> for (T0,)
2090 {
2091 #[inline]
2092 unsafe fn encode(
2093 self,
2094 encoder: &mut fidl::encoding::Encoder<'_, D>,
2095 offset: usize,
2096 depth: fidl::encoding::Depth,
2097 ) -> fidl::Result<()> {
2098 encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2099 self.0.encode(encoder, offset + 0, depth)?;
2103 Ok(())
2104 }
2105 }
2106
2107 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2108 for PublicationResponderOnPublicationResponse
2109 {
2110 #[inline(always)]
2111 fn new_empty() -> Self {
2112 Self { publication: fidl::new_empty!(fidl::encoding::Boxed<Publication>, D) }
2113 }
2114
2115 #[inline]
2116 unsafe fn decode(
2117 &mut self,
2118 decoder: &mut fidl::encoding::Decoder<'_, D>,
2119 offset: usize,
2120 _depth: fidl::encoding::Depth,
2121 ) -> fidl::Result<()> {
2122 decoder.debug_check_bounds::<Self>(offset);
2123 fidl::decode!(
2125 fidl::encoding::Boxed<Publication>,
2126 D,
2127 &mut self.publication,
2128 decoder,
2129 offset + 0,
2130 _depth
2131 )?;
2132 Ok(())
2133 }
2134 }
2135
2136 impl fidl::encoding::ValueTypeMarker for PublicationResponderSetSubtypesRequest {
2137 type Borrowed<'a> = &'a Self;
2138 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2139 value
2140 }
2141 }
2142
2143 unsafe impl fidl::encoding::TypeMarker for PublicationResponderSetSubtypesRequest {
2144 type Owned = Self;
2145
2146 #[inline(always)]
2147 fn inline_align(_context: fidl::encoding::Context) -> usize {
2148 8
2149 }
2150
2151 #[inline(always)]
2152 fn inline_size(_context: fidl::encoding::Context) -> usize {
2153 16
2154 }
2155 }
2156
2157 unsafe impl<D: fidl::encoding::ResourceDialect>
2158 fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D>
2159 for &PublicationResponderSetSubtypesRequest
2160 {
2161 #[inline]
2162 unsafe fn encode(
2163 self,
2164 encoder: &mut fidl::encoding::Encoder<'_, D>,
2165 offset: usize,
2166 _depth: fidl::encoding::Depth,
2167 ) -> fidl::Result<()> {
2168 encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2169 fidl::encoding::Encode::<PublicationResponderSetSubtypesRequest, D>::encode(
2171 (
2172 <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2173 ),
2174 encoder, offset, _depth
2175 )
2176 }
2177 }
2178 unsafe impl<
2179 D: fidl::encoding::ResourceDialect,
2180 T0: fidl::encoding::Encode<
2181 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2182 D,
2183 >,
2184 > fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D> for (T0,)
2185 {
2186 #[inline]
2187 unsafe fn encode(
2188 self,
2189 encoder: &mut fidl::encoding::Encoder<'_, D>,
2190 offset: usize,
2191 depth: fidl::encoding::Depth,
2192 ) -> fidl::Result<()> {
2193 encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2194 self.0.encode(encoder, offset + 0, depth)?;
2198 Ok(())
2199 }
2200 }
2201
2202 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2203 for PublicationResponderSetSubtypesRequest
2204 {
2205 #[inline(always)]
2206 fn new_empty() -> Self {
2207 Self {
2208 subtypes: fidl::new_empty!(
2209 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2210 D
2211 ),
2212 }
2213 }
2214
2215 #[inline]
2216 unsafe fn decode(
2217 &mut self,
2218 decoder: &mut fidl::encoding::Decoder<'_, D>,
2219 offset: usize,
2220 _depth: fidl::encoding::Depth,
2221 ) -> fidl::Result<()> {
2222 decoder.debug_check_bounds::<Self>(offset);
2223 fidl::decode!(
2225 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2226 D,
2227 &mut self.subtypes,
2228 decoder,
2229 offset + 0,
2230 _depth
2231 )?;
2232 Ok(())
2233 }
2234 }
2235
2236 impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameRequest {
2237 type Borrowed<'a> = &'a Self;
2238 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2239 value
2240 }
2241 }
2242
2243 unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameRequest {
2244 type Owned = Self;
2245
2246 #[inline(always)]
2247 fn inline_align(_context: fidl::encoding::Context) -> usize {
2248 8
2249 }
2250
2251 #[inline(always)]
2252 fn inline_size(_context: fidl::encoding::Context) -> usize {
2253 24
2254 }
2255 }
2256
2257 unsafe impl<D: fidl::encoding::ResourceDialect>
2258 fidl::encoding::Encode<ResolverResolveHostNameRequest, D>
2259 for &ResolverResolveHostNameRequest
2260 {
2261 #[inline]
2262 unsafe fn encode(
2263 self,
2264 encoder: &mut fidl::encoding::Encoder<'_, D>,
2265 offset: usize,
2266 _depth: fidl::encoding::Depth,
2267 ) -> fidl::Result<()> {
2268 encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2269 fidl::encoding::Encode::<ResolverResolveHostNameRequest, D>::encode(
2271 (
2272 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
2273 &self.host,
2274 ),
2275 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2276 ),
2277 encoder,
2278 offset,
2279 _depth,
2280 )
2281 }
2282 }
2283 unsafe impl<
2284 D: fidl::encoding::ResourceDialect,
2285 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2286 T1: fidl::encoding::Encode<i64, D>,
2287 > fidl::encoding::Encode<ResolverResolveHostNameRequest, D> for (T0, T1)
2288 {
2289 #[inline]
2290 unsafe fn encode(
2291 self,
2292 encoder: &mut fidl::encoding::Encoder<'_, D>,
2293 offset: usize,
2294 depth: fidl::encoding::Depth,
2295 ) -> fidl::Result<()> {
2296 encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2297 self.0.encode(encoder, offset + 0, depth)?;
2301 self.1.encode(encoder, offset + 16, depth)?;
2302 Ok(())
2303 }
2304 }
2305
2306 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2307 for ResolverResolveHostNameRequest
2308 {
2309 #[inline(always)]
2310 fn new_empty() -> Self {
2311 Self {
2312 host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2313 timeout: fidl::new_empty!(i64, D),
2314 }
2315 }
2316
2317 #[inline]
2318 unsafe fn decode(
2319 &mut self,
2320 decoder: &mut fidl::encoding::Decoder<'_, D>,
2321 offset: usize,
2322 _depth: fidl::encoding::Depth,
2323 ) -> fidl::Result<()> {
2324 decoder.debug_check_bounds::<Self>(offset);
2325 fidl::decode!(
2327 fidl::encoding::BoundedString<255>,
2328 D,
2329 &mut self.host,
2330 decoder,
2331 offset + 0,
2332 _depth
2333 )?;
2334 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
2335 Ok(())
2336 }
2337 }
2338
2339 impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameResponse {
2340 type Borrowed<'a> = &'a Self;
2341 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2342 value
2343 }
2344 }
2345
2346 unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameResponse {
2347 type Owned = Self;
2348
2349 #[inline(always)]
2350 fn inline_align(_context: fidl::encoding::Context) -> usize {
2351 8
2352 }
2353
2354 #[inline(always)]
2355 fn inline_size(_context: fidl::encoding::Context) -> usize {
2356 16
2357 }
2358 }
2359
2360 unsafe impl<D: fidl::encoding::ResourceDialect>
2361 fidl::encoding::Encode<ResolverResolveHostNameResponse, D>
2362 for &ResolverResolveHostNameResponse
2363 {
2364 #[inline]
2365 unsafe fn encode(
2366 self,
2367 encoder: &mut fidl::encoding::Encoder<'_, D>,
2368 offset: usize,
2369 _depth: fidl::encoding::Depth,
2370 ) -> fidl::Result<()> {
2371 encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2372 fidl::encoding::Encode::<ResolverResolveHostNameResponse, D>::encode(
2374 (
2375 <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v4_address),
2376 <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v6_address),
2377 ),
2378 encoder, offset, _depth
2379 )
2380 }
2381 }
2382 unsafe impl<
2383 D: fidl::encoding::ResourceDialect,
2384 T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>, D>,
2385 T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>, D>,
2386 > fidl::encoding::Encode<ResolverResolveHostNameResponse, D> for (T0, T1)
2387 {
2388 #[inline]
2389 unsafe fn encode(
2390 self,
2391 encoder: &mut fidl::encoding::Encoder<'_, D>,
2392 offset: usize,
2393 depth: fidl::encoding::Depth,
2394 ) -> fidl::Result<()> {
2395 encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2396 self.0.encode(encoder, offset + 0, depth)?;
2400 self.1.encode(encoder, offset + 8, depth)?;
2401 Ok(())
2402 }
2403 }
2404
2405 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2406 for ResolverResolveHostNameResponse
2407 {
2408 #[inline(always)]
2409 fn new_empty() -> Self {
2410 Self {
2411 v4_address: fidl::new_empty!(
2412 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2413 D
2414 ),
2415 v6_address: fidl::new_empty!(
2416 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2417 D
2418 ),
2419 }
2420 }
2421
2422 #[inline]
2423 unsafe fn decode(
2424 &mut self,
2425 decoder: &mut fidl::encoding::Decoder<'_, D>,
2426 offset: usize,
2427 _depth: fidl::encoding::Depth,
2428 ) -> fidl::Result<()> {
2429 decoder.debug_check_bounds::<Self>(offset);
2430 fidl::decode!(
2432 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2433 D,
2434 &mut self.v4_address,
2435 decoder,
2436 offset + 0,
2437 _depth
2438 )?;
2439 fidl::decode!(
2440 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2441 D,
2442 &mut self.v6_address,
2443 decoder,
2444 offset + 8,
2445 _depth
2446 )?;
2447 Ok(())
2448 }
2449 }
2450
2451 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2452 type Borrowed<'a> = &'a Self;
2453 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2454 value
2455 }
2456 }
2457
2458 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2459 type Owned = Self;
2460
2461 #[inline(always)]
2462 fn inline_align(_context: fidl::encoding::Context) -> usize {
2463 8
2464 }
2465
2466 #[inline(always)]
2467 fn inline_size(_context: fidl::encoding::Context) -> usize {
2468 40
2469 }
2470 }
2471
2472 unsafe impl<D: fidl::encoding::ResourceDialect>
2473 fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2474 for &ServiceInstancePublicationResponderOnPublicationRequest
2475 {
2476 #[inline]
2477 unsafe fn encode(
2478 self,
2479 encoder: &mut fidl::encoding::Encoder<'_, D>,
2480 offset: usize,
2481 _depth: fidl::encoding::Depth,
2482 ) -> fidl::Result<()> {
2483 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2484 offset,
2485 );
2486 fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationRequest, D>::encode(
2488 (
2489 <ServiceInstancePublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
2490 <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
2491 <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
2492 ),
2493 encoder, offset, _depth
2494 )
2495 }
2496 }
2497 unsafe impl<
2498 D: fidl::encoding::ResourceDialect,
2499 T0: fidl::encoding::Encode<ServiceInstancePublicationCause, D>,
2500 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
2501 T2: fidl::encoding::Encode<
2502 fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
2503 D,
2504 >,
2505 > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2506 for (T0, T1, T2)
2507 {
2508 #[inline]
2509 unsafe fn encode(
2510 self,
2511 encoder: &mut fidl::encoding::Encoder<'_, D>,
2512 offset: usize,
2513 depth: fidl::encoding::Depth,
2514 ) -> fidl::Result<()> {
2515 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2516 offset,
2517 );
2518 unsafe {
2521 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2522 (ptr as *mut u64).write_unaligned(0);
2523 }
2524 self.0.encode(encoder, offset + 0, depth)?;
2526 self.1.encode(encoder, offset + 8, depth)?;
2527 self.2.encode(encoder, offset + 24, depth)?;
2528 Ok(())
2529 }
2530 }
2531
2532 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2533 for ServiceInstancePublicationResponderOnPublicationRequest
2534 {
2535 #[inline(always)]
2536 fn new_empty() -> Self {
2537 Self {
2538 publication_cause: fidl::new_empty!(ServiceInstancePublicationCause, D),
2539 subtype: fidl::new_empty!(
2540 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2541 D
2542 ),
2543 source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
2544 }
2545 }
2546
2547 #[inline]
2548 unsafe fn decode(
2549 &mut self,
2550 decoder: &mut fidl::encoding::Decoder<'_, D>,
2551 offset: usize,
2552 _depth: fidl::encoding::Depth,
2553 ) -> fidl::Result<()> {
2554 decoder.debug_check_bounds::<Self>(offset);
2555 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2557 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2558 let mask = 0xffffffff00000000u64;
2559 let maskedval = padval & mask;
2560 if maskedval != 0 {
2561 return Err(fidl::Error::NonZeroPadding {
2562 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2563 });
2564 }
2565 fidl::decode!(
2566 ServiceInstancePublicationCause,
2567 D,
2568 &mut self.publication_cause,
2569 decoder,
2570 offset + 0,
2571 _depth
2572 )?;
2573 fidl::decode!(
2574 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2575 D,
2576 &mut self.subtype,
2577 decoder,
2578 offset + 8,
2579 _depth
2580 )?;
2581 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
2582 Ok(())
2583 }
2584 }
2585
2586 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2587 type Borrowed<'a> = &'a Self;
2588 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2589 value
2590 }
2591 }
2592
2593 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2594 type Owned = Self;
2595
2596 #[inline(always)]
2597 fn inline_align(_context: fidl::encoding::Context) -> usize {
2598 8
2599 }
2600
2601 #[inline(always)]
2602 fn inline_size(_context: fidl::encoding::Context) -> usize {
2603 16
2604 }
2605 }
2606
2607 unsafe impl<D: fidl::encoding::ResourceDialect>
2608 fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2609 for &ServiceInstancePublicationResponderSetSubtypesRequest
2610 {
2611 #[inline]
2612 unsafe fn encode(
2613 self,
2614 encoder: &mut fidl::encoding::Encoder<'_, D>,
2615 offset: usize,
2616 _depth: fidl::encoding::Depth,
2617 ) -> fidl::Result<()> {
2618 encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2619 offset,
2620 );
2621 fidl::encoding::Encode::<ServiceInstancePublicationResponderSetSubtypesRequest, D>::encode(
2623 (
2624 <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2625 ),
2626 encoder, offset, _depth
2627 )
2628 }
2629 }
2630 unsafe impl<
2631 D: fidl::encoding::ResourceDialect,
2632 T0: fidl::encoding::Encode<
2633 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2634 D,
2635 >,
2636 > fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2637 for (T0,)
2638 {
2639 #[inline]
2640 unsafe fn encode(
2641 self,
2642 encoder: &mut fidl::encoding::Encoder<'_, D>,
2643 offset: usize,
2644 depth: fidl::encoding::Depth,
2645 ) -> fidl::Result<()> {
2646 encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2647 offset,
2648 );
2649 self.0.encode(encoder, offset + 0, depth)?;
2653 Ok(())
2654 }
2655 }
2656
2657 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2658 for ServiceInstancePublicationResponderSetSubtypesRequest
2659 {
2660 #[inline(always)]
2661 fn new_empty() -> Self {
2662 Self {
2663 subtypes: fidl::new_empty!(
2664 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2665 D
2666 ),
2667 }
2668 }
2669
2670 #[inline]
2671 unsafe fn decode(
2672 &mut self,
2673 decoder: &mut fidl::encoding::Decoder<'_, D>,
2674 offset: usize,
2675 _depth: fidl::encoding::Depth,
2676 ) -> fidl::Result<()> {
2677 decoder.debug_check_bounds::<Self>(offset);
2678 fidl::decode!(
2680 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2681 D,
2682 &mut self.subtypes,
2683 decoder,
2684 offset + 0,
2685 _depth
2686 )?;
2687 Ok(())
2688 }
2689 }
2690
2691 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationResponse {
2692 type Borrowed<'a> = &'a Self;
2693 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2694 value
2695 }
2696 }
2697
2698 unsafe impl fidl::encoding::TypeMarker
2699 for ServiceInstancePublicationResponderOnPublicationResponse
2700 {
2701 type Owned = Self;
2702
2703 #[inline(always)]
2704 fn inline_align(_context: fidl::encoding::Context) -> usize {
2705 8
2706 }
2707
2708 #[inline(always)]
2709 fn inline_size(_context: fidl::encoding::Context) -> usize {
2710 16
2711 }
2712 }
2713
2714 unsafe impl<D: fidl::encoding::ResourceDialect>
2715 fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2716 for &ServiceInstancePublicationResponderOnPublicationResponse
2717 {
2718 #[inline]
2719 unsafe fn encode(
2720 self,
2721 encoder: &mut fidl::encoding::Encoder<'_, D>,
2722 offset: usize,
2723 _depth: fidl::encoding::Depth,
2724 ) -> fidl::Result<()> {
2725 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2726 offset,
2727 );
2728 fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationResponse, D>::encode(
2730 (
2731 <ServiceInstancePublication as fidl::encoding::ValueTypeMarker>::borrow(&self.publication),
2732 ),
2733 encoder, offset, _depth
2734 )
2735 }
2736 }
2737 unsafe impl<
2738 D: fidl::encoding::ResourceDialect,
2739 T0: fidl::encoding::Encode<ServiceInstancePublication, D>,
2740 > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2741 for (T0,)
2742 {
2743 #[inline]
2744 unsafe fn encode(
2745 self,
2746 encoder: &mut fidl::encoding::Encoder<'_, D>,
2747 offset: usize,
2748 depth: fidl::encoding::Depth,
2749 ) -> fidl::Result<()> {
2750 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2751 offset,
2752 );
2753 self.0.encode(encoder, offset + 0, depth)?;
2757 Ok(())
2758 }
2759 }
2760
2761 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2762 for ServiceInstancePublicationResponderOnPublicationResponse
2763 {
2764 #[inline(always)]
2765 fn new_empty() -> Self {
2766 Self { publication: fidl::new_empty!(ServiceInstancePublication, D) }
2767 }
2768
2769 #[inline]
2770 unsafe fn decode(
2771 &mut self,
2772 decoder: &mut fidl::encoding::Decoder<'_, D>,
2773 offset: usize,
2774 _depth: fidl::encoding::Depth,
2775 ) -> fidl::Result<()> {
2776 decoder.debug_check_bounds::<Self>(offset);
2777 fidl::decode!(
2779 ServiceInstancePublication,
2780 D,
2781 &mut self.publication,
2782 decoder,
2783 offset + 0,
2784 _depth
2785 )?;
2786 Ok(())
2787 }
2788 }
2789
2790 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2791 type Borrowed<'a> = &'a Self;
2792 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2793 value
2794 }
2795 }
2796
2797 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2798 type Owned = Self;
2799
2800 #[inline(always)]
2801 fn inline_align(_context: fidl::encoding::Context) -> usize {
2802 8
2803 }
2804
2805 #[inline(always)]
2806 fn inline_size(_context: fidl::encoding::Context) -> usize {
2807 56
2808 }
2809 }
2810
2811 unsafe impl<D: fidl::encoding::ResourceDialect>
2812 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2813 for &ServiceInstanceResolverResolveServiceInstanceRequest
2814 {
2815 #[inline]
2816 unsafe fn encode(
2817 self,
2818 encoder: &mut fidl::encoding::Encoder<'_, D>,
2819 offset: usize,
2820 _depth: fidl::encoding::Depth,
2821 ) -> fidl::Result<()> {
2822 encoder
2823 .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2824 fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceRequest, D>::encode(
2826 (
2827 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(&self.service),
2828 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2829 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2830 <ServiceInstanceResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2831 ),
2832 encoder, offset, _depth
2833 )
2834 }
2835 }
2836 unsafe impl<
2837 D: fidl::encoding::ResourceDialect,
2838 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
2839 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
2840 T2: fidl::encoding::Encode<i64, D>,
2841 T3: fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>,
2842 > fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2843 for (T0, T1, T2, T3)
2844 {
2845 #[inline]
2846 unsafe fn encode(
2847 self,
2848 encoder: &mut fidl::encoding::Encoder<'_, D>,
2849 offset: usize,
2850 depth: fidl::encoding::Depth,
2851 ) -> fidl::Result<()> {
2852 encoder
2853 .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2854 self.0.encode(encoder, offset + 0, depth)?;
2858 self.1.encode(encoder, offset + 16, depth)?;
2859 self.2.encode(encoder, offset + 32, depth)?;
2860 self.3.encode(encoder, offset + 40, depth)?;
2861 Ok(())
2862 }
2863 }
2864
2865 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2866 for ServiceInstanceResolverResolveServiceInstanceRequest
2867 {
2868 #[inline(always)]
2869 fn new_empty() -> Self {
2870 Self {
2871 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
2872 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
2873 timeout: fidl::new_empty!(i64, D),
2874 options: fidl::new_empty!(ServiceInstanceResolutionOptions, D),
2875 }
2876 }
2877
2878 #[inline]
2879 unsafe fn decode(
2880 &mut self,
2881 decoder: &mut fidl::encoding::Decoder<'_, D>,
2882 offset: usize,
2883 _depth: fidl::encoding::Depth,
2884 ) -> fidl::Result<()> {
2885 decoder.debug_check_bounds::<Self>(offset);
2886 fidl::decode!(
2888 fidl::encoding::BoundedString<22>,
2889 D,
2890 &mut self.service,
2891 decoder,
2892 offset + 0,
2893 _depth
2894 )?;
2895 fidl::decode!(
2896 fidl::encoding::BoundedString<63>,
2897 D,
2898 &mut self.instance,
2899 decoder,
2900 offset + 16,
2901 _depth
2902 )?;
2903 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 32, _depth)?;
2904 fidl::decode!(
2905 ServiceInstanceResolutionOptions,
2906 D,
2907 &mut self.options,
2908 decoder,
2909 offset + 40,
2910 _depth
2911 )?;
2912 Ok(())
2913 }
2914 }
2915
2916 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2917 type Borrowed<'a> = &'a Self;
2918 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2919 value
2920 }
2921 }
2922
2923 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2924 type Owned = Self;
2925
2926 #[inline(always)]
2927 fn inline_align(_context: fidl::encoding::Context) -> usize {
2928 8
2929 }
2930
2931 #[inline(always)]
2932 fn inline_size(_context: fidl::encoding::Context) -> usize {
2933 16
2934 }
2935 }
2936
2937 unsafe impl<D: fidl::encoding::ResourceDialect>
2938 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D>
2939 for &ServiceInstanceResolverResolveServiceInstanceResponse
2940 {
2941 #[inline]
2942 unsafe fn encode(
2943 self,
2944 encoder: &mut fidl::encoding::Encoder<'_, D>,
2945 offset: usize,
2946 _depth: fidl::encoding::Depth,
2947 ) -> fidl::Result<()> {
2948 encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2949 offset,
2950 );
2951 fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceResponse, D>::encode(
2953 (
2954 <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2955 ),
2956 encoder, offset, _depth
2957 )
2958 }
2959 }
2960 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
2961 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D> for (T0,)
2962 {
2963 #[inline]
2964 unsafe fn encode(
2965 self,
2966 encoder: &mut fidl::encoding::Encoder<'_, D>,
2967 offset: usize,
2968 depth: fidl::encoding::Depth,
2969 ) -> fidl::Result<()> {
2970 encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2971 offset,
2972 );
2973 self.0.encode(encoder, offset + 0, depth)?;
2977 Ok(())
2978 }
2979 }
2980
2981 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2982 for ServiceInstanceResolverResolveServiceInstanceResponse
2983 {
2984 #[inline(always)]
2985 fn new_empty() -> Self {
2986 Self { instance: fidl::new_empty!(ServiceInstance, D) }
2987 }
2988
2989 #[inline]
2990 unsafe fn decode(
2991 &mut self,
2992 decoder: &mut fidl::encoding::Decoder<'_, D>,
2993 offset: usize,
2994 _depth: fidl::encoding::Depth,
2995 ) -> fidl::Result<()> {
2996 decoder.debug_check_bounds::<Self>(offset);
2997 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
2999 Ok(())
3000 }
3001 }
3002
3003 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceChangedRequest {
3004 type Borrowed<'a> = &'a Self;
3005 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3006 value
3007 }
3008 }
3009
3010 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceChangedRequest {
3011 type Owned = Self;
3012
3013 #[inline(always)]
3014 fn inline_align(_context: fidl::encoding::Context) -> usize {
3015 8
3016 }
3017
3018 #[inline(always)]
3019 fn inline_size(_context: fidl::encoding::Context) -> usize {
3020 16
3021 }
3022 }
3023
3024 unsafe impl<D: fidl::encoding::ResourceDialect>
3025 fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D>
3026 for &ServiceSubscriberOnInstanceChangedRequest
3027 {
3028 #[inline]
3029 unsafe fn encode(
3030 self,
3031 encoder: &mut fidl::encoding::Encoder<'_, D>,
3032 offset: usize,
3033 _depth: fidl::encoding::Depth,
3034 ) -> fidl::Result<()> {
3035 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
3036 fidl::encoding::Encode::<ServiceSubscriberOnInstanceChangedRequest, D>::encode(
3038 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3039 encoder,
3040 offset,
3041 _depth,
3042 )
3043 }
3044 }
3045 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3046 fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D> for (T0,)
3047 {
3048 #[inline]
3049 unsafe fn encode(
3050 self,
3051 encoder: &mut fidl::encoding::Encoder<'_, D>,
3052 offset: usize,
3053 depth: fidl::encoding::Depth,
3054 ) -> fidl::Result<()> {
3055 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
3056 self.0.encode(encoder, offset + 0, depth)?;
3060 Ok(())
3061 }
3062 }
3063
3064 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3065 for ServiceSubscriberOnInstanceChangedRequest
3066 {
3067 #[inline(always)]
3068 fn new_empty() -> Self {
3069 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3070 }
3071
3072 #[inline]
3073 unsafe fn decode(
3074 &mut self,
3075 decoder: &mut fidl::encoding::Decoder<'_, D>,
3076 offset: usize,
3077 _depth: fidl::encoding::Depth,
3078 ) -> fidl::Result<()> {
3079 decoder.debug_check_bounds::<Self>(offset);
3080 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3082 Ok(())
3083 }
3084 }
3085
3086 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3087 type Borrowed<'a> = &'a Self;
3088 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3089 value
3090 }
3091 }
3092
3093 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3094 type Owned = Self;
3095
3096 #[inline(always)]
3097 fn inline_align(_context: fidl::encoding::Context) -> usize {
3098 8
3099 }
3100
3101 #[inline(always)]
3102 fn inline_size(_context: fidl::encoding::Context) -> usize {
3103 16
3104 }
3105 }
3106
3107 unsafe impl<D: fidl::encoding::ResourceDialect>
3108 fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D>
3109 for &ServiceSubscriberOnInstanceDiscoveredRequest
3110 {
3111 #[inline]
3112 unsafe fn encode(
3113 self,
3114 encoder: &mut fidl::encoding::Encoder<'_, D>,
3115 offset: usize,
3116 _depth: fidl::encoding::Depth,
3117 ) -> fidl::Result<()> {
3118 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3119 fidl::encoding::Encode::<ServiceSubscriberOnInstanceDiscoveredRequest, D>::encode(
3121 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3122 encoder,
3123 offset,
3124 _depth,
3125 )
3126 }
3127 }
3128 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3129 fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D> for (T0,)
3130 {
3131 #[inline]
3132 unsafe fn encode(
3133 self,
3134 encoder: &mut fidl::encoding::Encoder<'_, D>,
3135 offset: usize,
3136 depth: fidl::encoding::Depth,
3137 ) -> fidl::Result<()> {
3138 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3139 self.0.encode(encoder, offset + 0, depth)?;
3143 Ok(())
3144 }
3145 }
3146
3147 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3148 for ServiceSubscriberOnInstanceDiscoveredRequest
3149 {
3150 #[inline(always)]
3151 fn new_empty() -> Self {
3152 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3153 }
3154
3155 #[inline]
3156 unsafe fn decode(
3157 &mut self,
3158 decoder: &mut fidl::encoding::Decoder<'_, D>,
3159 offset: usize,
3160 _depth: fidl::encoding::Depth,
3161 ) -> fidl::Result<()> {
3162 decoder.debug_check_bounds::<Self>(offset);
3163 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3165 Ok(())
3166 }
3167 }
3168
3169 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceLostRequest {
3170 type Borrowed<'a> = &'a Self;
3171 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3172 value
3173 }
3174 }
3175
3176 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceLostRequest {
3177 type Owned = Self;
3178
3179 #[inline(always)]
3180 fn inline_align(_context: fidl::encoding::Context) -> usize {
3181 8
3182 }
3183
3184 #[inline(always)]
3185 fn inline_size(_context: fidl::encoding::Context) -> usize {
3186 32
3187 }
3188 }
3189
3190 unsafe impl<D: fidl::encoding::ResourceDialect>
3191 fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D>
3192 for &ServiceSubscriberOnInstanceLostRequest
3193 {
3194 #[inline]
3195 unsafe fn encode(
3196 self,
3197 encoder: &mut fidl::encoding::Encoder<'_, D>,
3198 offset: usize,
3199 _depth: fidl::encoding::Depth,
3200 ) -> fidl::Result<()> {
3201 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3202 fidl::encoding::Encode::<ServiceSubscriberOnInstanceLostRequest, D>::encode(
3204 (
3205 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3206 &self.service,
3207 ),
3208 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3209 &self.instance,
3210 ),
3211 ),
3212 encoder,
3213 offset,
3214 _depth,
3215 )
3216 }
3217 }
3218 unsafe impl<
3219 D: fidl::encoding::ResourceDialect,
3220 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3221 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3222 > fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D> for (T0, T1)
3223 {
3224 #[inline]
3225 unsafe fn encode(
3226 self,
3227 encoder: &mut fidl::encoding::Encoder<'_, D>,
3228 offset: usize,
3229 depth: fidl::encoding::Depth,
3230 ) -> fidl::Result<()> {
3231 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3232 self.0.encode(encoder, offset + 0, depth)?;
3236 self.1.encode(encoder, offset + 16, depth)?;
3237 Ok(())
3238 }
3239 }
3240
3241 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3242 for ServiceSubscriberOnInstanceLostRequest
3243 {
3244 #[inline(always)]
3245 fn new_empty() -> Self {
3246 Self {
3247 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3248 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3249 }
3250 }
3251
3252 #[inline]
3253 unsafe fn decode(
3254 &mut self,
3255 decoder: &mut fidl::encoding::Decoder<'_, D>,
3256 offset: usize,
3257 _depth: fidl::encoding::Depth,
3258 ) -> fidl::Result<()> {
3259 decoder.debug_check_bounds::<Self>(offset);
3260 fidl::decode!(
3262 fidl::encoding::BoundedString<22>,
3263 D,
3264 &mut self.service,
3265 decoder,
3266 offset + 0,
3267 _depth
3268 )?;
3269 fidl::decode!(
3270 fidl::encoding::BoundedString<63>,
3271 D,
3272 &mut self.instance,
3273 decoder,
3274 offset + 16,
3275 _depth
3276 )?;
3277 Ok(())
3278 }
3279 }
3280
3281 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnQueryRequest {
3282 type Borrowed<'a> = &'a Self;
3283 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3284 value
3285 }
3286 }
3287
3288 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnQueryRequest {
3289 type Owned = Self;
3290
3291 #[inline(always)]
3292 fn inline_align(_context: fidl::encoding::Context) -> usize {
3293 4
3294 }
3295
3296 #[inline(always)]
3297 fn inline_size(_context: fidl::encoding::Context) -> usize {
3298 4
3299 }
3300 }
3301
3302 unsafe impl<D: fidl::encoding::ResourceDialect>
3303 fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D>
3304 for &ServiceSubscriberOnQueryRequest
3305 {
3306 #[inline]
3307 unsafe fn encode(
3308 self,
3309 encoder: &mut fidl::encoding::Encoder<'_, D>,
3310 offset: usize,
3311 _depth: fidl::encoding::Depth,
3312 ) -> fidl::Result<()> {
3313 encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3314 fidl::encoding::Encode::<ServiceSubscriberOnQueryRequest, D>::encode(
3316 (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3317 encoder,
3318 offset,
3319 _depth,
3320 )
3321 }
3322 }
3323 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3324 fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D> for (T0,)
3325 {
3326 #[inline]
3327 unsafe fn encode(
3328 self,
3329 encoder: &mut fidl::encoding::Encoder<'_, D>,
3330 offset: usize,
3331 depth: fidl::encoding::Depth,
3332 ) -> fidl::Result<()> {
3333 encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3334 self.0.encode(encoder, offset + 0, depth)?;
3338 Ok(())
3339 }
3340 }
3341
3342 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3343 for ServiceSubscriberOnQueryRequest
3344 {
3345 #[inline(always)]
3346 fn new_empty() -> Self {
3347 Self { resource_type: fidl::new_empty!(ResourceType, D) }
3348 }
3349
3350 #[inline]
3351 unsafe fn decode(
3352 &mut self,
3353 decoder: &mut fidl::encoding::Decoder<'_, D>,
3354 offset: usize,
3355 _depth: fidl::encoding::Depth,
3356 ) -> fidl::Result<()> {
3357 decoder.debug_check_bounds::<Self>(offset);
3358 fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3360 Ok(())
3361 }
3362 }
3363
3364 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3365 type Borrowed<'a> = &'a Self;
3366 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3367 value
3368 }
3369 }
3370
3371 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3372 type Owned = Self;
3373
3374 #[inline(always)]
3375 fn inline_align(_context: fidl::encoding::Context) -> usize {
3376 8
3377 }
3378
3379 #[inline(always)]
3380 fn inline_size(_context: fidl::encoding::Context) -> usize {
3381 16
3382 }
3383 }
3384
3385 unsafe impl<D: fidl::encoding::ResourceDialect>
3386 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D>
3387 for &ServiceSubscriptionListenerOnInstanceChangedRequest
3388 {
3389 #[inline]
3390 unsafe fn encode(
3391 self,
3392 encoder: &mut fidl::encoding::Encoder<'_, D>,
3393 offset: usize,
3394 _depth: fidl::encoding::Depth,
3395 ) -> fidl::Result<()> {
3396 encoder
3397 .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3398 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceChangedRequest, D>::encode(
3400 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3401 encoder,
3402 offset,
3403 _depth,
3404 )
3405 }
3406 }
3407 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3408 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D> for (T0,)
3409 {
3410 #[inline]
3411 unsafe fn encode(
3412 self,
3413 encoder: &mut fidl::encoding::Encoder<'_, D>,
3414 offset: usize,
3415 depth: fidl::encoding::Depth,
3416 ) -> fidl::Result<()> {
3417 encoder
3418 .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3419 self.0.encode(encoder, offset + 0, depth)?;
3423 Ok(())
3424 }
3425 }
3426
3427 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3428 for ServiceSubscriptionListenerOnInstanceChangedRequest
3429 {
3430 #[inline(always)]
3431 fn new_empty() -> Self {
3432 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3433 }
3434
3435 #[inline]
3436 unsafe fn decode(
3437 &mut self,
3438 decoder: &mut fidl::encoding::Decoder<'_, D>,
3439 offset: usize,
3440 _depth: fidl::encoding::Depth,
3441 ) -> fidl::Result<()> {
3442 decoder.debug_check_bounds::<Self>(offset);
3443 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3445 Ok(())
3446 }
3447 }
3448
3449 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3450 type Borrowed<'a> = &'a Self;
3451 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3452 value
3453 }
3454 }
3455
3456 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3457 type Owned = Self;
3458
3459 #[inline(always)]
3460 fn inline_align(_context: fidl::encoding::Context) -> usize {
3461 8
3462 }
3463
3464 #[inline(always)]
3465 fn inline_size(_context: fidl::encoding::Context) -> usize {
3466 16
3467 }
3468 }
3469
3470 unsafe impl<D: fidl::encoding::ResourceDialect>
3471 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>
3472 for &ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3473 {
3474 #[inline]
3475 unsafe fn encode(
3476 self,
3477 encoder: &mut fidl::encoding::Encoder<'_, D>,
3478 offset: usize,
3479 _depth: fidl::encoding::Depth,
3480 ) -> fidl::Result<()> {
3481 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3482 offset,
3483 );
3484 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>::encode(
3486 (
3487 <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
3488 ),
3489 encoder, offset, _depth
3490 )
3491 }
3492 }
3493 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3494 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D> for (T0,)
3495 {
3496 #[inline]
3497 unsafe fn encode(
3498 self,
3499 encoder: &mut fidl::encoding::Encoder<'_, D>,
3500 offset: usize,
3501 depth: fidl::encoding::Depth,
3502 ) -> fidl::Result<()> {
3503 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3504 offset,
3505 );
3506 self.0.encode(encoder, offset + 0, depth)?;
3510 Ok(())
3511 }
3512 }
3513
3514 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3515 for ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3516 {
3517 #[inline(always)]
3518 fn new_empty() -> Self {
3519 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3520 }
3521
3522 #[inline]
3523 unsafe fn decode(
3524 &mut self,
3525 decoder: &mut fidl::encoding::Decoder<'_, D>,
3526 offset: usize,
3527 _depth: fidl::encoding::Depth,
3528 ) -> fidl::Result<()> {
3529 decoder.debug_check_bounds::<Self>(offset);
3530 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3532 Ok(())
3533 }
3534 }
3535
3536 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3537 type Borrowed<'a> = &'a Self;
3538 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3539 value
3540 }
3541 }
3542
3543 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3544 type Owned = Self;
3545
3546 #[inline(always)]
3547 fn inline_align(_context: fidl::encoding::Context) -> usize {
3548 8
3549 }
3550
3551 #[inline(always)]
3552 fn inline_size(_context: fidl::encoding::Context) -> usize {
3553 32
3554 }
3555 }
3556
3557 unsafe impl<D: fidl::encoding::ResourceDialect>
3558 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D>
3559 for &ServiceSubscriptionListenerOnInstanceLostRequest
3560 {
3561 #[inline]
3562 unsafe fn encode(
3563 self,
3564 encoder: &mut fidl::encoding::Encoder<'_, D>,
3565 offset: usize,
3566 _depth: fidl::encoding::Depth,
3567 ) -> fidl::Result<()> {
3568 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3569 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceLostRequest, D>::encode(
3571 (
3572 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3573 &self.service,
3574 ),
3575 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3576 &self.instance,
3577 ),
3578 ),
3579 encoder,
3580 offset,
3581 _depth,
3582 )
3583 }
3584 }
3585 unsafe impl<
3586 D: fidl::encoding::ResourceDialect,
3587 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3588 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3589 > fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D> for (T0, T1)
3590 {
3591 #[inline]
3592 unsafe fn encode(
3593 self,
3594 encoder: &mut fidl::encoding::Encoder<'_, D>,
3595 offset: usize,
3596 depth: fidl::encoding::Depth,
3597 ) -> fidl::Result<()> {
3598 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3599 self.0.encode(encoder, offset + 0, depth)?;
3603 self.1.encode(encoder, offset + 16, depth)?;
3604 Ok(())
3605 }
3606 }
3607
3608 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3609 for ServiceSubscriptionListenerOnInstanceLostRequest
3610 {
3611 #[inline(always)]
3612 fn new_empty() -> Self {
3613 Self {
3614 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3615 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3616 }
3617 }
3618
3619 #[inline]
3620 unsafe fn decode(
3621 &mut self,
3622 decoder: &mut fidl::encoding::Decoder<'_, D>,
3623 offset: usize,
3624 _depth: fidl::encoding::Depth,
3625 ) -> fidl::Result<()> {
3626 decoder.debug_check_bounds::<Self>(offset);
3627 fidl::decode!(
3629 fidl::encoding::BoundedString<22>,
3630 D,
3631 &mut self.service,
3632 decoder,
3633 offset + 0,
3634 _depth
3635 )?;
3636 fidl::decode!(
3637 fidl::encoding::BoundedString<63>,
3638 D,
3639 &mut self.instance,
3640 decoder,
3641 offset + 16,
3642 _depth
3643 )?;
3644 Ok(())
3645 }
3646 }
3647
3648 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3649 type Borrowed<'a> = &'a Self;
3650 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3651 value
3652 }
3653 }
3654
3655 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3656 type Owned = Self;
3657
3658 #[inline(always)]
3659 fn inline_align(_context: fidl::encoding::Context) -> usize {
3660 4
3661 }
3662
3663 #[inline(always)]
3664 fn inline_size(_context: fidl::encoding::Context) -> usize {
3665 4
3666 }
3667 }
3668
3669 unsafe impl<D: fidl::encoding::ResourceDialect>
3670 fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D>
3671 for &ServiceSubscriptionListenerOnQueryRequest
3672 {
3673 #[inline]
3674 unsafe fn encode(
3675 self,
3676 encoder: &mut fidl::encoding::Encoder<'_, D>,
3677 offset: usize,
3678 _depth: fidl::encoding::Depth,
3679 ) -> fidl::Result<()> {
3680 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3681 fidl::encoding::Encode::<ServiceSubscriptionListenerOnQueryRequest, D>::encode(
3683 (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3684 encoder,
3685 offset,
3686 _depth,
3687 )
3688 }
3689 }
3690 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3691 fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D> for (T0,)
3692 {
3693 #[inline]
3694 unsafe fn encode(
3695 self,
3696 encoder: &mut fidl::encoding::Encoder<'_, D>,
3697 offset: usize,
3698 depth: fidl::encoding::Depth,
3699 ) -> fidl::Result<()> {
3700 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3701 self.0.encode(encoder, offset + 0, depth)?;
3705 Ok(())
3706 }
3707 }
3708
3709 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3710 for ServiceSubscriptionListenerOnQueryRequest
3711 {
3712 #[inline(always)]
3713 fn new_empty() -> Self {
3714 Self { resource_type: fidl::new_empty!(ResourceType, D) }
3715 }
3716
3717 #[inline]
3718 unsafe fn decode(
3719 &mut self,
3720 decoder: &mut fidl::encoding::Decoder<'_, D>,
3721 offset: usize,
3722 _depth: fidl::encoding::Depth,
3723 ) -> fidl::Result<()> {
3724 decoder.debug_check_bounds::<Self>(offset);
3725 fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3727 Ok(())
3728 }
3729 }
3730
3731 impl HostNameResolutionOptions {
3732 #[inline(always)]
3733 fn max_ordinal_present(&self) -> u64 {
3734 if let Some(_) = self.exclude_local_proxies {
3735 return 4;
3736 }
3737 if let Some(_) = self.exclude_local {
3738 return 3;
3739 }
3740 if let Some(_) = self.ip_versions {
3741 return 2;
3742 }
3743 if let Some(_) = self.media {
3744 return 1;
3745 }
3746 0
3747 }
3748 }
3749
3750 impl fidl::encoding::ValueTypeMarker for HostNameResolutionOptions {
3751 type Borrowed<'a> = &'a Self;
3752 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3753 value
3754 }
3755 }
3756
3757 unsafe impl fidl::encoding::TypeMarker for HostNameResolutionOptions {
3758 type Owned = Self;
3759
3760 #[inline(always)]
3761 fn inline_align(_context: fidl::encoding::Context) -> usize {
3762 8
3763 }
3764
3765 #[inline(always)]
3766 fn inline_size(_context: fidl::encoding::Context) -> usize {
3767 16
3768 }
3769 }
3770
3771 unsafe impl<D: fidl::encoding::ResourceDialect>
3772 fidl::encoding::Encode<HostNameResolutionOptions, D> for &HostNameResolutionOptions
3773 {
3774 unsafe fn encode(
3775 self,
3776 encoder: &mut fidl::encoding::Encoder<'_, D>,
3777 offset: usize,
3778 mut depth: fidl::encoding::Depth,
3779 ) -> fidl::Result<()> {
3780 encoder.debug_check_bounds::<HostNameResolutionOptions>(offset);
3781 let max_ordinal: u64 = self.max_ordinal_present();
3783 encoder.write_num(max_ordinal, offset);
3784 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3785 if max_ordinal == 0 {
3787 return Ok(());
3788 }
3789 depth.increment()?;
3790 let envelope_size = 8;
3791 let bytes_len = max_ordinal as usize * envelope_size;
3792 #[allow(unused_variables)]
3793 let offset = encoder.out_of_line_offset(bytes_len);
3794 let mut _prev_end_offset: usize = 0;
3795 if 1 > max_ordinal {
3796 return Ok(());
3797 }
3798
3799 let cur_offset: usize = (1 - 1) * envelope_size;
3802
3803 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3805
3806 fidl::encoding::encode_in_envelope_optional::<Media, D>(
3811 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
3812 encoder,
3813 offset + cur_offset,
3814 depth,
3815 )?;
3816
3817 _prev_end_offset = cur_offset + envelope_size;
3818 if 2 > max_ordinal {
3819 return Ok(());
3820 }
3821
3822 let cur_offset: usize = (2 - 1) * envelope_size;
3825
3826 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3828
3829 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
3834 self.ip_versions
3835 .as_ref()
3836 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
3837 encoder,
3838 offset + cur_offset,
3839 depth,
3840 )?;
3841
3842 _prev_end_offset = cur_offset + envelope_size;
3843 if 3 > max_ordinal {
3844 return Ok(());
3845 }
3846
3847 let cur_offset: usize = (3 - 1) * envelope_size;
3850
3851 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3853
3854 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3859 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3860 encoder,
3861 offset + cur_offset,
3862 depth,
3863 )?;
3864
3865 _prev_end_offset = cur_offset + envelope_size;
3866 if 4 > max_ordinal {
3867 return Ok(());
3868 }
3869
3870 let cur_offset: usize = (4 - 1) * envelope_size;
3873
3874 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3876
3877 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3882 self.exclude_local_proxies
3883 .as_ref()
3884 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3885 encoder,
3886 offset + cur_offset,
3887 depth,
3888 )?;
3889
3890 _prev_end_offset = cur_offset + envelope_size;
3891
3892 Ok(())
3893 }
3894 }
3895
3896 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3897 for HostNameResolutionOptions
3898 {
3899 #[inline(always)]
3900 fn new_empty() -> Self {
3901 Self::default()
3902 }
3903
3904 unsafe fn decode(
3905 &mut self,
3906 decoder: &mut fidl::encoding::Decoder<'_, D>,
3907 offset: usize,
3908 mut depth: fidl::encoding::Depth,
3909 ) -> fidl::Result<()> {
3910 decoder.debug_check_bounds::<Self>(offset);
3911 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3912 None => return Err(fidl::Error::NotNullable),
3913 Some(len) => len,
3914 };
3915 if len == 0 {
3917 return Ok(());
3918 };
3919 depth.increment()?;
3920 let envelope_size = 8;
3921 let bytes_len = len * envelope_size;
3922 let offset = decoder.out_of_line_offset(bytes_len)?;
3923 let mut _next_ordinal_to_read = 0;
3925 let mut next_offset = offset;
3926 let end_offset = offset + bytes_len;
3927 _next_ordinal_to_read += 1;
3928 if next_offset >= end_offset {
3929 return Ok(());
3930 }
3931
3932 while _next_ordinal_to_read < 1 {
3934 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3935 _next_ordinal_to_read += 1;
3936 next_offset += envelope_size;
3937 }
3938
3939 let next_out_of_line = decoder.next_out_of_line();
3940 let handles_before = decoder.remaining_handles();
3941 if let Some((inlined, num_bytes, num_handles)) =
3942 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3943 {
3944 let member_inline_size =
3945 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3946 if inlined != (member_inline_size <= 4) {
3947 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3948 }
3949 let inner_offset;
3950 let mut inner_depth = depth.clone();
3951 if inlined {
3952 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3953 inner_offset = next_offset;
3954 } else {
3955 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3956 inner_depth.increment()?;
3957 }
3958 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
3959 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
3960 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3961 {
3962 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3963 }
3964 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3965 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3966 }
3967 }
3968
3969 next_offset += envelope_size;
3970 _next_ordinal_to_read += 1;
3971 if next_offset >= end_offset {
3972 return Ok(());
3973 }
3974
3975 while _next_ordinal_to_read < 2 {
3977 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3978 _next_ordinal_to_read += 1;
3979 next_offset += envelope_size;
3980 }
3981
3982 let next_out_of_line = decoder.next_out_of_line();
3983 let handles_before = decoder.remaining_handles();
3984 if let Some((inlined, num_bytes, num_handles)) =
3985 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3986 {
3987 let member_inline_size =
3988 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3989 if inlined != (member_inline_size <= 4) {
3990 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3991 }
3992 let inner_offset;
3993 let mut inner_depth = depth.clone();
3994 if inlined {
3995 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3996 inner_offset = next_offset;
3997 } else {
3998 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3999 inner_depth.increment()?;
4000 }
4001 let val_ref =
4002 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4003 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4004 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4005 {
4006 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4007 }
4008 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4009 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4010 }
4011 }
4012
4013 next_offset += envelope_size;
4014 _next_ordinal_to_read += 1;
4015 if next_offset >= end_offset {
4016 return Ok(());
4017 }
4018
4019 while _next_ordinal_to_read < 3 {
4021 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4022 _next_ordinal_to_read += 1;
4023 next_offset += envelope_size;
4024 }
4025
4026 let next_out_of_line = decoder.next_out_of_line();
4027 let handles_before = decoder.remaining_handles();
4028 if let Some((inlined, num_bytes, num_handles)) =
4029 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4030 {
4031 let member_inline_size =
4032 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4033 if inlined != (member_inline_size <= 4) {
4034 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4035 }
4036 let inner_offset;
4037 let mut inner_depth = depth.clone();
4038 if inlined {
4039 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4040 inner_offset = next_offset;
4041 } else {
4042 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4043 inner_depth.increment()?;
4044 }
4045 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
4046 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4047 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4048 {
4049 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4050 }
4051 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4052 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4053 }
4054 }
4055
4056 next_offset += envelope_size;
4057 _next_ordinal_to_read += 1;
4058 if next_offset >= end_offset {
4059 return Ok(());
4060 }
4061
4062 while _next_ordinal_to_read < 4 {
4064 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4065 _next_ordinal_to_read += 1;
4066 next_offset += envelope_size;
4067 }
4068
4069 let next_out_of_line = decoder.next_out_of_line();
4070 let handles_before = decoder.remaining_handles();
4071 if let Some((inlined, num_bytes, num_handles)) =
4072 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4073 {
4074 let member_inline_size =
4075 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4076 if inlined != (member_inline_size <= 4) {
4077 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4078 }
4079 let inner_offset;
4080 let mut inner_depth = depth.clone();
4081 if inlined {
4082 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4083 inner_offset = next_offset;
4084 } else {
4085 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4086 inner_depth.increment()?;
4087 }
4088 let val_ref =
4089 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4090 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4091 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4092 {
4093 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4094 }
4095 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4096 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4097 }
4098 }
4099
4100 next_offset += envelope_size;
4101
4102 while next_offset < end_offset {
4104 _next_ordinal_to_read += 1;
4105 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4106 next_offset += envelope_size;
4107 }
4108
4109 Ok(())
4110 }
4111 }
4112
4113 impl HostNameSubscriptionOptions {
4114 #[inline(always)]
4115 fn max_ordinal_present(&self) -> u64 {
4116 if let Some(_) = self.exclude_local_proxies {
4117 return 4;
4118 }
4119 if let Some(_) = self.exclude_local {
4120 return 3;
4121 }
4122 if let Some(_) = self.ip_versions {
4123 return 2;
4124 }
4125 if let Some(_) = self.media {
4126 return 1;
4127 }
4128 0
4129 }
4130 }
4131
4132 impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionOptions {
4133 type Borrowed<'a> = &'a Self;
4134 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4135 value
4136 }
4137 }
4138
4139 unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionOptions {
4140 type Owned = Self;
4141
4142 #[inline(always)]
4143 fn inline_align(_context: fidl::encoding::Context) -> usize {
4144 8
4145 }
4146
4147 #[inline(always)]
4148 fn inline_size(_context: fidl::encoding::Context) -> usize {
4149 16
4150 }
4151 }
4152
4153 unsafe impl<D: fidl::encoding::ResourceDialect>
4154 fidl::encoding::Encode<HostNameSubscriptionOptions, D> for &HostNameSubscriptionOptions
4155 {
4156 unsafe fn encode(
4157 self,
4158 encoder: &mut fidl::encoding::Encoder<'_, D>,
4159 offset: usize,
4160 mut depth: fidl::encoding::Depth,
4161 ) -> fidl::Result<()> {
4162 encoder.debug_check_bounds::<HostNameSubscriptionOptions>(offset);
4163 let max_ordinal: u64 = self.max_ordinal_present();
4165 encoder.write_num(max_ordinal, offset);
4166 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4167 if max_ordinal == 0 {
4169 return Ok(());
4170 }
4171 depth.increment()?;
4172 let envelope_size = 8;
4173 let bytes_len = max_ordinal as usize * envelope_size;
4174 #[allow(unused_variables)]
4175 let offset = encoder.out_of_line_offset(bytes_len);
4176 let mut _prev_end_offset: usize = 0;
4177 if 1 > max_ordinal {
4178 return Ok(());
4179 }
4180
4181 let cur_offset: usize = (1 - 1) * envelope_size;
4184
4185 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4187
4188 fidl::encoding::encode_in_envelope_optional::<Media, D>(
4193 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4194 encoder,
4195 offset + cur_offset,
4196 depth,
4197 )?;
4198
4199 _prev_end_offset = cur_offset + envelope_size;
4200 if 2 > max_ordinal {
4201 return Ok(());
4202 }
4203
4204 let cur_offset: usize = (2 - 1) * envelope_size;
4207
4208 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4210
4211 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4216 self.ip_versions
4217 .as_ref()
4218 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4219 encoder,
4220 offset + cur_offset,
4221 depth,
4222 )?;
4223
4224 _prev_end_offset = cur_offset + envelope_size;
4225 if 3 > max_ordinal {
4226 return Ok(());
4227 }
4228
4229 let cur_offset: usize = (3 - 1) * envelope_size;
4232
4233 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4235
4236 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4241 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4242 encoder,
4243 offset + cur_offset,
4244 depth,
4245 )?;
4246
4247 _prev_end_offset = cur_offset + envelope_size;
4248 if 4 > max_ordinal {
4249 return Ok(());
4250 }
4251
4252 let cur_offset: usize = (4 - 1) * envelope_size;
4255
4256 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4258
4259 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4264 self.exclude_local_proxies
4265 .as_ref()
4266 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4267 encoder,
4268 offset + cur_offset,
4269 depth,
4270 )?;
4271
4272 _prev_end_offset = cur_offset + envelope_size;
4273
4274 Ok(())
4275 }
4276 }
4277
4278 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4279 for HostNameSubscriptionOptions
4280 {
4281 #[inline(always)]
4282 fn new_empty() -> Self {
4283 Self::default()
4284 }
4285
4286 unsafe fn decode(
4287 &mut self,
4288 decoder: &mut fidl::encoding::Decoder<'_, D>,
4289 offset: usize,
4290 mut depth: fidl::encoding::Depth,
4291 ) -> fidl::Result<()> {
4292 decoder.debug_check_bounds::<Self>(offset);
4293 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4294 None => return Err(fidl::Error::NotNullable),
4295 Some(len) => len,
4296 };
4297 if len == 0 {
4299 return Ok(());
4300 };
4301 depth.increment()?;
4302 let envelope_size = 8;
4303 let bytes_len = len * envelope_size;
4304 let offset = decoder.out_of_line_offset(bytes_len)?;
4305 let mut _next_ordinal_to_read = 0;
4307 let mut next_offset = offset;
4308 let end_offset = offset + bytes_len;
4309 _next_ordinal_to_read += 1;
4310 if next_offset >= end_offset {
4311 return Ok(());
4312 }
4313
4314 while _next_ordinal_to_read < 1 {
4316 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4317 _next_ordinal_to_read += 1;
4318 next_offset += envelope_size;
4319 }
4320
4321 let next_out_of_line = decoder.next_out_of_line();
4322 let handles_before = decoder.remaining_handles();
4323 if let Some((inlined, num_bytes, num_handles)) =
4324 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4325 {
4326 let member_inline_size =
4327 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4328 if inlined != (member_inline_size <= 4) {
4329 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4330 }
4331 let inner_offset;
4332 let mut inner_depth = depth.clone();
4333 if inlined {
4334 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4335 inner_offset = next_offset;
4336 } else {
4337 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4338 inner_depth.increment()?;
4339 }
4340 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4341 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4342 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4343 {
4344 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4345 }
4346 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4347 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4348 }
4349 }
4350
4351 next_offset += envelope_size;
4352 _next_ordinal_to_read += 1;
4353 if next_offset >= end_offset {
4354 return Ok(());
4355 }
4356
4357 while _next_ordinal_to_read < 2 {
4359 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4360 _next_ordinal_to_read += 1;
4361 next_offset += envelope_size;
4362 }
4363
4364 let next_out_of_line = decoder.next_out_of_line();
4365 let handles_before = decoder.remaining_handles();
4366 if let Some((inlined, num_bytes, num_handles)) =
4367 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4368 {
4369 let member_inline_size =
4370 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4371 if inlined != (member_inline_size <= 4) {
4372 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4373 }
4374 let inner_offset;
4375 let mut inner_depth = depth.clone();
4376 if inlined {
4377 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4378 inner_offset = next_offset;
4379 } else {
4380 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4381 inner_depth.increment()?;
4382 }
4383 let val_ref =
4384 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4385 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4386 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4387 {
4388 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4389 }
4390 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4391 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4392 }
4393 }
4394
4395 next_offset += envelope_size;
4396 _next_ordinal_to_read += 1;
4397 if next_offset >= end_offset {
4398 return Ok(());
4399 }
4400
4401 while _next_ordinal_to_read < 3 {
4403 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4404 _next_ordinal_to_read += 1;
4405 next_offset += envelope_size;
4406 }
4407
4408 let next_out_of_line = decoder.next_out_of_line();
4409 let handles_before = decoder.remaining_handles();
4410 if let Some((inlined, num_bytes, num_handles)) =
4411 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4412 {
4413 let member_inline_size =
4414 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4415 if inlined != (member_inline_size <= 4) {
4416 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4417 }
4418 let inner_offset;
4419 let mut inner_depth = depth.clone();
4420 if inlined {
4421 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4422 inner_offset = next_offset;
4423 } else {
4424 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4425 inner_depth.increment()?;
4426 }
4427 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
4428 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4429 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4430 {
4431 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4432 }
4433 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4434 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4435 }
4436 }
4437
4438 next_offset += envelope_size;
4439 _next_ordinal_to_read += 1;
4440 if next_offset >= end_offset {
4441 return Ok(());
4442 }
4443
4444 while _next_ordinal_to_read < 4 {
4446 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4447 _next_ordinal_to_read += 1;
4448 next_offset += envelope_size;
4449 }
4450
4451 let next_out_of_line = decoder.next_out_of_line();
4452 let handles_before = decoder.remaining_handles();
4453 if let Some((inlined, num_bytes, num_handles)) =
4454 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4455 {
4456 let member_inline_size =
4457 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4458 if inlined != (member_inline_size <= 4) {
4459 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4460 }
4461 let inner_offset;
4462 let mut inner_depth = depth.clone();
4463 if inlined {
4464 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4465 inner_offset = next_offset;
4466 } else {
4467 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4468 inner_depth.increment()?;
4469 }
4470 let val_ref =
4471 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4472 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4473 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4474 {
4475 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4476 }
4477 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4478 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4479 }
4480 }
4481
4482 next_offset += envelope_size;
4483
4484 while next_offset < end_offset {
4486 _next_ordinal_to_read += 1;
4487 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4488 next_offset += envelope_size;
4489 }
4490
4491 Ok(())
4492 }
4493 }
4494
4495 impl ProxyHostPublicationOptions {
4496 #[inline(always)]
4497 fn max_ordinal_present(&self) -> u64 {
4498 if let Some(_) = self.perform_probe {
4499 return 3;
4500 }
4501 if let Some(_) = self.ip_versions {
4502 return 2;
4503 }
4504 if let Some(_) = self.media {
4505 return 1;
4506 }
4507 0
4508 }
4509 }
4510
4511 impl fidl::encoding::ValueTypeMarker for ProxyHostPublicationOptions {
4512 type Borrowed<'a> = &'a Self;
4513 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4514 value
4515 }
4516 }
4517
4518 unsafe impl fidl::encoding::TypeMarker for ProxyHostPublicationOptions {
4519 type Owned = Self;
4520
4521 #[inline(always)]
4522 fn inline_align(_context: fidl::encoding::Context) -> usize {
4523 8
4524 }
4525
4526 #[inline(always)]
4527 fn inline_size(_context: fidl::encoding::Context) -> usize {
4528 16
4529 }
4530 }
4531
4532 unsafe impl<D: fidl::encoding::ResourceDialect>
4533 fidl::encoding::Encode<ProxyHostPublicationOptions, D> for &ProxyHostPublicationOptions
4534 {
4535 unsafe fn encode(
4536 self,
4537 encoder: &mut fidl::encoding::Encoder<'_, D>,
4538 offset: usize,
4539 mut depth: fidl::encoding::Depth,
4540 ) -> fidl::Result<()> {
4541 encoder.debug_check_bounds::<ProxyHostPublicationOptions>(offset);
4542 let max_ordinal: u64 = self.max_ordinal_present();
4544 encoder.write_num(max_ordinal, offset);
4545 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4546 if max_ordinal == 0 {
4548 return Ok(());
4549 }
4550 depth.increment()?;
4551 let envelope_size = 8;
4552 let bytes_len = max_ordinal as usize * envelope_size;
4553 #[allow(unused_variables)]
4554 let offset = encoder.out_of_line_offset(bytes_len);
4555 let mut _prev_end_offset: usize = 0;
4556 if 1 > max_ordinal {
4557 return Ok(());
4558 }
4559
4560 let cur_offset: usize = (1 - 1) * envelope_size;
4563
4564 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4566
4567 fidl::encoding::encode_in_envelope_optional::<Media, D>(
4572 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4573 encoder,
4574 offset + cur_offset,
4575 depth,
4576 )?;
4577
4578 _prev_end_offset = cur_offset + envelope_size;
4579 if 2 > max_ordinal {
4580 return Ok(());
4581 }
4582
4583 let cur_offset: usize = (2 - 1) * envelope_size;
4586
4587 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4589
4590 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4595 self.ip_versions
4596 .as_ref()
4597 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4598 encoder,
4599 offset + cur_offset,
4600 depth,
4601 )?;
4602
4603 _prev_end_offset = cur_offset + envelope_size;
4604 if 3 > max_ordinal {
4605 return Ok(());
4606 }
4607
4608 let cur_offset: usize = (3 - 1) * envelope_size;
4611
4612 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4614
4615 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4620 self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4621 encoder,
4622 offset + cur_offset,
4623 depth,
4624 )?;
4625
4626 _prev_end_offset = cur_offset + envelope_size;
4627
4628 Ok(())
4629 }
4630 }
4631
4632 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4633 for ProxyHostPublicationOptions
4634 {
4635 #[inline(always)]
4636 fn new_empty() -> Self {
4637 Self::default()
4638 }
4639
4640 unsafe fn decode(
4641 &mut self,
4642 decoder: &mut fidl::encoding::Decoder<'_, D>,
4643 offset: usize,
4644 mut depth: fidl::encoding::Depth,
4645 ) -> fidl::Result<()> {
4646 decoder.debug_check_bounds::<Self>(offset);
4647 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4648 None => return Err(fidl::Error::NotNullable),
4649 Some(len) => len,
4650 };
4651 if len == 0 {
4653 return Ok(());
4654 };
4655 depth.increment()?;
4656 let envelope_size = 8;
4657 let bytes_len = len * envelope_size;
4658 let offset = decoder.out_of_line_offset(bytes_len)?;
4659 let mut _next_ordinal_to_read = 0;
4661 let mut next_offset = offset;
4662 let end_offset = offset + bytes_len;
4663 _next_ordinal_to_read += 1;
4664 if next_offset >= end_offset {
4665 return Ok(());
4666 }
4667
4668 while _next_ordinal_to_read < 1 {
4670 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4671 _next_ordinal_to_read += 1;
4672 next_offset += envelope_size;
4673 }
4674
4675 let next_out_of_line = decoder.next_out_of_line();
4676 let handles_before = decoder.remaining_handles();
4677 if let Some((inlined, num_bytes, num_handles)) =
4678 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4679 {
4680 let member_inline_size =
4681 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4682 if inlined != (member_inline_size <= 4) {
4683 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4684 }
4685 let inner_offset;
4686 let mut inner_depth = depth.clone();
4687 if inlined {
4688 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4689 inner_offset = next_offset;
4690 } else {
4691 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4692 inner_depth.increment()?;
4693 }
4694 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4695 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4696 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4697 {
4698 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4699 }
4700 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4701 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4702 }
4703 }
4704
4705 next_offset += envelope_size;
4706 _next_ordinal_to_read += 1;
4707 if next_offset >= end_offset {
4708 return Ok(());
4709 }
4710
4711 while _next_ordinal_to_read < 2 {
4713 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4714 _next_ordinal_to_read += 1;
4715 next_offset += envelope_size;
4716 }
4717
4718 let next_out_of_line = decoder.next_out_of_line();
4719 let handles_before = decoder.remaining_handles();
4720 if let Some((inlined, num_bytes, num_handles)) =
4721 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4722 {
4723 let member_inline_size =
4724 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4725 if inlined != (member_inline_size <= 4) {
4726 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4727 }
4728 let inner_offset;
4729 let mut inner_depth = depth.clone();
4730 if inlined {
4731 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4732 inner_offset = next_offset;
4733 } else {
4734 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4735 inner_depth.increment()?;
4736 }
4737 let val_ref =
4738 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4739 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4740 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4741 {
4742 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4743 }
4744 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4745 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4746 }
4747 }
4748
4749 next_offset += envelope_size;
4750 _next_ordinal_to_read += 1;
4751 if next_offset >= end_offset {
4752 return Ok(());
4753 }
4754
4755 while _next_ordinal_to_read < 3 {
4757 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4758 _next_ordinal_to_read += 1;
4759 next_offset += envelope_size;
4760 }
4761
4762 let next_out_of_line = decoder.next_out_of_line();
4763 let handles_before = decoder.remaining_handles();
4764 if let Some((inlined, num_bytes, num_handles)) =
4765 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4766 {
4767 let member_inline_size =
4768 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4769 if inlined != (member_inline_size <= 4) {
4770 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4771 }
4772 let inner_offset;
4773 let mut inner_depth = depth.clone();
4774 if inlined {
4775 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4776 inner_offset = next_offset;
4777 } else {
4778 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4779 inner_depth.increment()?;
4780 }
4781 let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
4782 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4783 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4784 {
4785 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4786 }
4787 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4788 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4789 }
4790 }
4791
4792 next_offset += envelope_size;
4793
4794 while next_offset < end_offset {
4796 _next_ordinal_to_read += 1;
4797 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4798 next_offset += envelope_size;
4799 }
4800
4801 Ok(())
4802 }
4803 }
4804
4805 impl ServiceInstance {
4806 #[inline(always)]
4807 fn max_ordinal_present(&self) -> u64 {
4808 if let Some(_) = self.text_strings {
4809 return 10;
4810 }
4811 if let Some(_) = self.addresses {
4812 return 9;
4813 }
4814 if let Some(_) = self.target {
4815 return 8;
4816 }
4817 if let Some(_) = self.srv_weight {
4818 return 7;
4819 }
4820 if let Some(_) = self.srv_priority {
4821 return 6;
4822 }
4823 if let Some(_) = self.text {
4824 return 5;
4825 }
4826 if let Some(_) = self.ipv6_endpoint {
4827 return 4;
4828 }
4829 if let Some(_) = self.ipv4_endpoint {
4830 return 3;
4831 }
4832 if let Some(_) = self.instance {
4833 return 2;
4834 }
4835 if let Some(_) = self.service {
4836 return 1;
4837 }
4838 0
4839 }
4840 }
4841
4842 impl fidl::encoding::ValueTypeMarker for ServiceInstance {
4843 type Borrowed<'a> = &'a Self;
4844 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4845 value
4846 }
4847 }
4848
4849 unsafe impl fidl::encoding::TypeMarker for ServiceInstance {
4850 type Owned = Self;
4851
4852 #[inline(always)]
4853 fn inline_align(_context: fidl::encoding::Context) -> usize {
4854 8
4855 }
4856
4857 #[inline(always)]
4858 fn inline_size(_context: fidl::encoding::Context) -> usize {
4859 16
4860 }
4861 }
4862
4863 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceInstance, D>
4864 for &ServiceInstance
4865 {
4866 unsafe fn encode(
4867 self,
4868 encoder: &mut fidl::encoding::Encoder<'_, D>,
4869 offset: usize,
4870 mut depth: fidl::encoding::Depth,
4871 ) -> fidl::Result<()> {
4872 encoder.debug_check_bounds::<ServiceInstance>(offset);
4873 let max_ordinal: u64 = self.max_ordinal_present();
4875 encoder.write_num(max_ordinal, offset);
4876 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4877 if max_ordinal == 0 {
4879 return Ok(());
4880 }
4881 depth.increment()?;
4882 let envelope_size = 8;
4883 let bytes_len = max_ordinal as usize * envelope_size;
4884 #[allow(unused_variables)]
4885 let offset = encoder.out_of_line_offset(bytes_len);
4886 let mut _prev_end_offset: usize = 0;
4887 if 1 > max_ordinal {
4888 return Ok(());
4889 }
4890
4891 let cur_offset: usize = (1 - 1) * envelope_size;
4894
4895 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4897
4898 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<22>, D>(
4903 self.service.as_ref().map(
4904 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow,
4905 ),
4906 encoder,
4907 offset + cur_offset,
4908 depth,
4909 )?;
4910
4911 _prev_end_offset = cur_offset + envelope_size;
4912 if 2 > max_ordinal {
4913 return Ok(());
4914 }
4915
4916 let cur_offset: usize = (2 - 1) * envelope_size;
4919
4920 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4922
4923 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<63>, D>(
4928 self.instance.as_ref().map(
4929 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow,
4930 ),
4931 encoder,
4932 offset + cur_offset,
4933 depth,
4934 )?;
4935
4936 _prev_end_offset = cur_offset + envelope_size;
4937 if 3 > max_ordinal {
4938 return Ok(());
4939 }
4940
4941 let cur_offset: usize = (3 - 1) * envelope_size;
4944
4945 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4947
4948 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4SocketAddress, D>(
4953 self.ipv4_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4954 encoder, offset + cur_offset, depth
4955 )?;
4956
4957 _prev_end_offset = cur_offset + envelope_size;
4958 if 4 > max_ordinal {
4959 return Ok(());
4960 }
4961
4962 let cur_offset: usize = (4 - 1) * envelope_size;
4965
4966 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4968
4969 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6SocketAddress, D>(
4974 self.ipv6_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4975 encoder, offset + cur_offset, depth
4976 )?;
4977
4978 _prev_end_offset = cur_offset + envelope_size;
4979 if 5 > max_ordinal {
4980 return Ok(());
4981 }
4982
4983 let cur_offset: usize = (5 - 1) * envelope_size;
4986
4987 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4989
4990 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>, D>(
4995 self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
4996 encoder, offset + cur_offset, depth
4997 )?;
4998
4999 _prev_end_offset = cur_offset + envelope_size;
5000 if 6 > max_ordinal {
5001 return Ok(());
5002 }
5003
5004 let cur_offset: usize = (6 - 1) * envelope_size;
5007
5008 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5010
5011 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5016 self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5017 encoder,
5018 offset + cur_offset,
5019 depth,
5020 )?;
5021
5022 _prev_end_offset = cur_offset + envelope_size;
5023 if 7 > max_ordinal {
5024 return Ok(());
5025 }
5026
5027 let cur_offset: usize = (7 - 1) * envelope_size;
5030
5031 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5033
5034 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5039 self.srv_weight.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5040 encoder,
5041 offset + cur_offset,
5042 depth,
5043 )?;
5044
5045 _prev_end_offset = cur_offset + envelope_size;
5046 if 8 > max_ordinal {
5047 return Ok(());
5048 }
5049
5050 let cur_offset: usize = (8 - 1) * envelope_size;
5053
5054 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5056
5057 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
5062 self.target.as_ref().map(
5063 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
5064 ),
5065 encoder,
5066 offset + cur_offset,
5067 depth,
5068 )?;
5069
5070 _prev_end_offset = cur_offset + envelope_size;
5071 if 9 > max_ordinal {
5072 return Ok(());
5073 }
5074
5075 let cur_offset: usize = (9 - 1) * envelope_size;
5078
5079 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5081
5082 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D>(
5087 self.addresses.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5088 encoder, offset + cur_offset, depth
5089 )?;
5090
5091 _prev_end_offset = cur_offset + envelope_size;
5092 if 10 > max_ordinal {
5093 return Ok(());
5094 }
5095
5096 let cur_offset: usize = (10 - 1) * envelope_size;
5099
5100 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5102
5103 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5108 self.text_strings.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5109 encoder, offset + cur_offset, depth
5110 )?;
5111
5112 _prev_end_offset = cur_offset + envelope_size;
5113
5114 Ok(())
5115 }
5116 }
5117
5118 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceInstance {
5119 #[inline(always)]
5120 fn new_empty() -> Self {
5121 Self::default()
5122 }
5123
5124 unsafe fn decode(
5125 &mut self,
5126 decoder: &mut fidl::encoding::Decoder<'_, D>,
5127 offset: usize,
5128 mut depth: fidl::encoding::Depth,
5129 ) -> fidl::Result<()> {
5130 decoder.debug_check_bounds::<Self>(offset);
5131 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5132 None => return Err(fidl::Error::NotNullable),
5133 Some(len) => len,
5134 };
5135 if len == 0 {
5137 return Ok(());
5138 };
5139 depth.increment()?;
5140 let envelope_size = 8;
5141 let bytes_len = len * envelope_size;
5142 let offset = decoder.out_of_line_offset(bytes_len)?;
5143 let mut _next_ordinal_to_read = 0;
5145 let mut next_offset = offset;
5146 let end_offset = offset + bytes_len;
5147 _next_ordinal_to_read += 1;
5148 if next_offset >= end_offset {
5149 return Ok(());
5150 }
5151
5152 while _next_ordinal_to_read < 1 {
5154 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5155 _next_ordinal_to_read += 1;
5156 next_offset += envelope_size;
5157 }
5158
5159 let next_out_of_line = decoder.next_out_of_line();
5160 let handles_before = decoder.remaining_handles();
5161 if let Some((inlined, num_bytes, num_handles)) =
5162 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5163 {
5164 let member_inline_size =
5165 <fidl::encoding::BoundedString<22> as fidl::encoding::TypeMarker>::inline_size(
5166 decoder.context,
5167 );
5168 if inlined != (member_inline_size <= 4) {
5169 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5170 }
5171 let inner_offset;
5172 let mut inner_depth = depth.clone();
5173 if inlined {
5174 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5175 inner_offset = next_offset;
5176 } else {
5177 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5178 inner_depth.increment()?;
5179 }
5180 let val_ref = self
5181 .service
5182 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<22>, D));
5183 fidl::decode!(
5184 fidl::encoding::BoundedString<22>,
5185 D,
5186 val_ref,
5187 decoder,
5188 inner_offset,
5189 inner_depth
5190 )?;
5191 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5192 {
5193 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5194 }
5195 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5196 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5197 }
5198 }
5199
5200 next_offset += envelope_size;
5201 _next_ordinal_to_read += 1;
5202 if next_offset >= end_offset {
5203 return Ok(());
5204 }
5205
5206 while _next_ordinal_to_read < 2 {
5208 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5209 _next_ordinal_to_read += 1;
5210 next_offset += envelope_size;
5211 }
5212
5213 let next_out_of_line = decoder.next_out_of_line();
5214 let handles_before = decoder.remaining_handles();
5215 if let Some((inlined, num_bytes, num_handles)) =
5216 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5217 {
5218 let member_inline_size =
5219 <fidl::encoding::BoundedString<63> as fidl::encoding::TypeMarker>::inline_size(
5220 decoder.context,
5221 );
5222 if inlined != (member_inline_size <= 4) {
5223 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5224 }
5225 let inner_offset;
5226 let mut inner_depth = depth.clone();
5227 if inlined {
5228 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5229 inner_offset = next_offset;
5230 } else {
5231 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5232 inner_depth.increment()?;
5233 }
5234 let val_ref = self
5235 .instance
5236 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<63>, D));
5237 fidl::decode!(
5238 fidl::encoding::BoundedString<63>,
5239 D,
5240 val_ref,
5241 decoder,
5242 inner_offset,
5243 inner_depth
5244 )?;
5245 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5246 {
5247 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5248 }
5249 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5250 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5251 }
5252 }
5253
5254 next_offset += envelope_size;
5255 _next_ordinal_to_read += 1;
5256 if next_offset >= end_offset {
5257 return Ok(());
5258 }
5259
5260 while _next_ordinal_to_read < 3 {
5262 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5263 _next_ordinal_to_read += 1;
5264 next_offset += envelope_size;
5265 }
5266
5267 let next_out_of_line = decoder.next_out_of_line();
5268 let handles_before = decoder.remaining_handles();
5269 if let Some((inlined, num_bytes, num_handles)) =
5270 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5271 {
5272 let member_inline_size = <fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5273 if inlined != (member_inline_size <= 4) {
5274 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5275 }
5276 let inner_offset;
5277 let mut inner_depth = depth.clone();
5278 if inlined {
5279 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5280 inner_offset = next_offset;
5281 } else {
5282 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5283 inner_depth.increment()?;
5284 }
5285 let val_ref = self.ipv4_endpoint.get_or_insert_with(|| {
5286 fidl::new_empty!(fidl_fuchsia_net__common::Ipv4SocketAddress, D)
5287 });
5288 fidl::decode!(
5289 fidl_fuchsia_net__common::Ipv4SocketAddress,
5290 D,
5291 val_ref,
5292 decoder,
5293 inner_offset,
5294 inner_depth
5295 )?;
5296 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5297 {
5298 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5299 }
5300 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5301 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5302 }
5303 }
5304
5305 next_offset += envelope_size;
5306 _next_ordinal_to_read += 1;
5307 if next_offset >= end_offset {
5308 return Ok(());
5309 }
5310
5311 while _next_ordinal_to_read < 4 {
5313 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5314 _next_ordinal_to_read += 1;
5315 next_offset += envelope_size;
5316 }
5317
5318 let next_out_of_line = decoder.next_out_of_line();
5319 let handles_before = decoder.remaining_handles();
5320 if let Some((inlined, num_bytes, num_handles)) =
5321 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5322 {
5323 let member_inline_size = <fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5324 if inlined != (member_inline_size <= 4) {
5325 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5326 }
5327 let inner_offset;
5328 let mut inner_depth = depth.clone();
5329 if inlined {
5330 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5331 inner_offset = next_offset;
5332 } else {
5333 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5334 inner_depth.increment()?;
5335 }
5336 let val_ref = self.ipv6_endpoint.get_or_insert_with(|| {
5337 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6SocketAddress, D)
5338 });
5339 fidl::decode!(
5340 fidl_fuchsia_net__common::Ipv6SocketAddress,
5341 D,
5342 val_ref,
5343 decoder,
5344 inner_offset,
5345 inner_depth
5346 )?;
5347 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5348 {
5349 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5350 }
5351 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5352 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5353 }
5354 }
5355
5356 next_offset += envelope_size;
5357 _next_ordinal_to_read += 1;
5358 if next_offset >= end_offset {
5359 return Ok(());
5360 }
5361
5362 while _next_ordinal_to_read < 5 {
5364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5365 _next_ordinal_to_read += 1;
5366 next_offset += envelope_size;
5367 }
5368
5369 let next_out_of_line = decoder.next_out_of_line();
5370 let handles_before = decoder.remaining_handles();
5371 if let Some((inlined, num_bytes, num_handles)) =
5372 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5373 {
5374 let member_inline_size = <fidl::encoding::Vector<
5375 fidl::encoding::BoundedString<255>,
5376 256,
5377 > as fidl::encoding::TypeMarker>::inline_size(
5378 decoder.context
5379 );
5380 if inlined != (member_inline_size <= 4) {
5381 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5382 }
5383 let inner_offset;
5384 let mut inner_depth = depth.clone();
5385 if inlined {
5386 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5387 inner_offset = next_offset;
5388 } else {
5389 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5390 inner_depth.increment()?;
5391 }
5392 let val_ref = self.text.get_or_insert_with(|| {
5393 fidl::new_empty!(
5394 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5395 D
5396 )
5397 });
5398 fidl::decode!(
5399 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5400 D,
5401 val_ref,
5402 decoder,
5403 inner_offset,
5404 inner_depth
5405 )?;
5406 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5407 {
5408 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5409 }
5410 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5411 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5412 }
5413 }
5414
5415 next_offset += envelope_size;
5416 _next_ordinal_to_read += 1;
5417 if next_offset >= end_offset {
5418 return Ok(());
5419 }
5420
5421 while _next_ordinal_to_read < 6 {
5423 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5424 _next_ordinal_to_read += 1;
5425 next_offset += envelope_size;
5426 }
5427
5428 let next_out_of_line = decoder.next_out_of_line();
5429 let handles_before = decoder.remaining_handles();
5430 if let Some((inlined, num_bytes, num_handles)) =
5431 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5432 {
5433 let member_inline_size =
5434 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5435 if inlined != (member_inline_size <= 4) {
5436 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5437 }
5438 let inner_offset;
5439 let mut inner_depth = depth.clone();
5440 if inlined {
5441 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5442 inner_offset = next_offset;
5443 } else {
5444 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5445 inner_depth.increment()?;
5446 }
5447 let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
5448 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5449 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5450 {
5451 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5452 }
5453 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5454 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5455 }
5456 }
5457
5458 next_offset += envelope_size;
5459 _next_ordinal_to_read += 1;
5460 if next_offset >= end_offset {
5461 return Ok(());
5462 }
5463
5464 while _next_ordinal_to_read < 7 {
5466 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5467 _next_ordinal_to_read += 1;
5468 next_offset += envelope_size;
5469 }
5470
5471 let next_out_of_line = decoder.next_out_of_line();
5472 let handles_before = decoder.remaining_handles();
5473 if let Some((inlined, num_bytes, num_handles)) =
5474 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5475 {
5476 let member_inline_size =
5477 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5478 if inlined != (member_inline_size <= 4) {
5479 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5480 }
5481 let inner_offset;
5482 let mut inner_depth = depth.clone();
5483 if inlined {
5484 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5485 inner_offset = next_offset;
5486 } else {
5487 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5488 inner_depth.increment()?;
5489 }
5490 let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
5491 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5492 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5493 {
5494 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5495 }
5496 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5497 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5498 }
5499 }
5500
5501 next_offset += envelope_size;
5502 _next_ordinal_to_read += 1;
5503 if next_offset >= end_offset {
5504 return Ok(());
5505 }
5506
5507 while _next_ordinal_to_read < 8 {
5509 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5510 _next_ordinal_to_read += 1;
5511 next_offset += envelope_size;
5512 }
5513
5514 let next_out_of_line = decoder.next_out_of_line();
5515 let handles_before = decoder.remaining_handles();
5516 if let Some((inlined, num_bytes, num_handles)) =
5517 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5518 {
5519 let member_inline_size =
5520 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5521 decoder.context,
5522 );
5523 if inlined != (member_inline_size <= 4) {
5524 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5525 }
5526 let inner_offset;
5527 let mut inner_depth = depth.clone();
5528 if inlined {
5529 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5530 inner_offset = next_offset;
5531 } else {
5532 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5533 inner_depth.increment()?;
5534 }
5535 let val_ref = self
5536 .target
5537 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5538 fidl::decode!(
5539 fidl::encoding::BoundedString<255>,
5540 D,
5541 val_ref,
5542 decoder,
5543 inner_offset,
5544 inner_depth
5545 )?;
5546 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5547 {
5548 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5549 }
5550 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5551 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5552 }
5553 }
5554
5555 next_offset += envelope_size;
5556 _next_ordinal_to_read += 1;
5557 if next_offset >= end_offset {
5558 return Ok(());
5559 }
5560
5561 while _next_ordinal_to_read < 9 {
5563 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5564 _next_ordinal_to_read += 1;
5565 next_offset += envelope_size;
5566 }
5567
5568 let next_out_of_line = decoder.next_out_of_line();
5569 let handles_before = decoder.remaining_handles();
5570 if let Some((inlined, num_bytes, num_handles)) =
5571 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5572 {
5573 let member_inline_size = <fidl::encoding::Vector<
5574 fidl_fuchsia_net__common::SocketAddress,
5575 64,
5576 > as fidl::encoding::TypeMarker>::inline_size(
5577 decoder.context
5578 );
5579 if inlined != (member_inline_size <= 4) {
5580 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5581 }
5582 let inner_offset;
5583 let mut inner_depth = depth.clone();
5584 if inlined {
5585 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5586 inner_offset = next_offset;
5587 } else {
5588 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5589 inner_depth.increment()?;
5590 }
5591 let val_ref =
5592 self.addresses.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D));
5593 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5594 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5595 {
5596 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5597 }
5598 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5599 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5600 }
5601 }
5602
5603 next_offset += envelope_size;
5604 _next_ordinal_to_read += 1;
5605 if next_offset >= end_offset {
5606 return Ok(());
5607 }
5608
5609 while _next_ordinal_to_read < 10 {
5611 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5612 _next_ordinal_to_read += 1;
5613 next_offset += envelope_size;
5614 }
5615
5616 let next_out_of_line = decoder.next_out_of_line();
5617 let handles_before = decoder.remaining_handles();
5618 if let Some((inlined, num_bytes, num_handles)) =
5619 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5620 {
5621 let member_inline_size = <fidl::encoding::Vector<
5622 fidl::encoding::Vector<u8, 255>,
5623 256,
5624 > as fidl::encoding::TypeMarker>::inline_size(
5625 decoder.context
5626 );
5627 if inlined != (member_inline_size <= 4) {
5628 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5629 }
5630 let inner_offset;
5631 let mut inner_depth = depth.clone();
5632 if inlined {
5633 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5634 inner_offset = next_offset;
5635 } else {
5636 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5637 inner_depth.increment()?;
5638 }
5639 let val_ref = self.text_strings.get_or_insert_with(|| {
5640 fidl::new_empty!(
5641 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5642 D
5643 )
5644 });
5645 fidl::decode!(
5646 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5647 D,
5648 val_ref,
5649 decoder,
5650 inner_offset,
5651 inner_depth
5652 )?;
5653 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5654 {
5655 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5656 }
5657 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5658 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5659 }
5660 }
5661
5662 next_offset += envelope_size;
5663
5664 while next_offset < end_offset {
5666 _next_ordinal_to_read += 1;
5667 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5668 next_offset += envelope_size;
5669 }
5670
5671 Ok(())
5672 }
5673 }
5674
5675 impl ServiceInstancePublication {
5676 #[inline(always)]
5677 fn max_ordinal_present(&self) -> u64 {
5678 if let Some(_) = self.txt_ttl {
5679 return 7;
5680 }
5681 if let Some(_) = self.srv_ttl {
5682 return 6;
5683 }
5684 if let Some(_) = self.ptr_ttl {
5685 return 5;
5686 }
5687 if let Some(_) = self.srv_weight {
5688 return 4;
5689 }
5690 if let Some(_) = self.srv_priority {
5691 return 3;
5692 }
5693 if let Some(_) = self.text {
5694 return 2;
5695 }
5696 if let Some(_) = self.port {
5697 return 1;
5698 }
5699 0
5700 }
5701 }
5702
5703 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublication {
5704 type Borrowed<'a> = &'a Self;
5705 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5706 value
5707 }
5708 }
5709
5710 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublication {
5711 type Owned = Self;
5712
5713 #[inline(always)]
5714 fn inline_align(_context: fidl::encoding::Context) -> usize {
5715 8
5716 }
5717
5718 #[inline(always)]
5719 fn inline_size(_context: fidl::encoding::Context) -> usize {
5720 16
5721 }
5722 }
5723
5724 unsafe impl<D: fidl::encoding::ResourceDialect>
5725 fidl::encoding::Encode<ServiceInstancePublication, D> for &ServiceInstancePublication
5726 {
5727 unsafe fn encode(
5728 self,
5729 encoder: &mut fidl::encoding::Encoder<'_, D>,
5730 offset: usize,
5731 mut depth: fidl::encoding::Depth,
5732 ) -> fidl::Result<()> {
5733 encoder.debug_check_bounds::<ServiceInstancePublication>(offset);
5734 let max_ordinal: u64 = self.max_ordinal_present();
5736 encoder.write_num(max_ordinal, offset);
5737 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5738 if max_ordinal == 0 {
5740 return Ok(());
5741 }
5742 depth.increment()?;
5743 let envelope_size = 8;
5744 let bytes_len = max_ordinal as usize * envelope_size;
5745 #[allow(unused_variables)]
5746 let offset = encoder.out_of_line_offset(bytes_len);
5747 let mut _prev_end_offset: usize = 0;
5748 if 1 > max_ordinal {
5749 return Ok(());
5750 }
5751
5752 let cur_offset: usize = (1 - 1) * envelope_size;
5755
5756 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5758
5759 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5764 self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5765 encoder,
5766 offset + cur_offset,
5767 depth,
5768 )?;
5769
5770 _prev_end_offset = cur_offset + envelope_size;
5771 if 2 > max_ordinal {
5772 return Ok(());
5773 }
5774
5775 let cur_offset: usize = (2 - 1) * envelope_size;
5778
5779 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5781
5782 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5787 self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5788 encoder, offset + cur_offset, depth
5789 )?;
5790
5791 _prev_end_offset = cur_offset + envelope_size;
5792 if 3 > max_ordinal {
5793 return Ok(());
5794 }
5795
5796 let cur_offset: usize = (3 - 1) * envelope_size;
5799
5800 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5802
5803 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5808 self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5809 encoder,
5810 offset + cur_offset,
5811 depth,
5812 )?;
5813
5814 _prev_end_offset = cur_offset + envelope_size;
5815 if 4 > max_ordinal {
5816 return Ok(());
5817 }
5818
5819 let cur_offset: usize = (4 - 1) * envelope_size;
5822
5823 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5825
5826 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5831 self.srv_weight.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5832 encoder,
5833 offset + cur_offset,
5834 depth,
5835 )?;
5836
5837 _prev_end_offset = cur_offset + envelope_size;
5838 if 5 > max_ordinal {
5839 return Ok(());
5840 }
5841
5842 let cur_offset: usize = (5 - 1) * envelope_size;
5845
5846 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5848
5849 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5854 self.ptr_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5855 encoder,
5856 offset + cur_offset,
5857 depth,
5858 )?;
5859
5860 _prev_end_offset = cur_offset + envelope_size;
5861 if 6 > max_ordinal {
5862 return Ok(());
5863 }
5864
5865 let cur_offset: usize = (6 - 1) * envelope_size;
5868
5869 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5871
5872 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5877 self.srv_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5878 encoder,
5879 offset + cur_offset,
5880 depth,
5881 )?;
5882
5883 _prev_end_offset = cur_offset + envelope_size;
5884 if 7 > max_ordinal {
5885 return Ok(());
5886 }
5887
5888 let cur_offset: usize = (7 - 1) * envelope_size;
5891
5892 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5894
5895 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5900 self.txt_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5901 encoder,
5902 offset + cur_offset,
5903 depth,
5904 )?;
5905
5906 _prev_end_offset = cur_offset + envelope_size;
5907
5908 Ok(())
5909 }
5910 }
5911
5912 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5913 for ServiceInstancePublication
5914 {
5915 #[inline(always)]
5916 fn new_empty() -> Self {
5917 Self::default()
5918 }
5919
5920 unsafe fn decode(
5921 &mut self,
5922 decoder: &mut fidl::encoding::Decoder<'_, D>,
5923 offset: usize,
5924 mut depth: fidl::encoding::Depth,
5925 ) -> fidl::Result<()> {
5926 decoder.debug_check_bounds::<Self>(offset);
5927 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5928 None => return Err(fidl::Error::NotNullable),
5929 Some(len) => len,
5930 };
5931 if len == 0 {
5933 return Ok(());
5934 };
5935 depth.increment()?;
5936 let envelope_size = 8;
5937 let bytes_len = len * envelope_size;
5938 let offset = decoder.out_of_line_offset(bytes_len)?;
5939 let mut _next_ordinal_to_read = 0;
5941 let mut next_offset = offset;
5942 let end_offset = offset + bytes_len;
5943 _next_ordinal_to_read += 1;
5944 if next_offset >= end_offset {
5945 return Ok(());
5946 }
5947
5948 while _next_ordinal_to_read < 1 {
5950 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5951 _next_ordinal_to_read += 1;
5952 next_offset += envelope_size;
5953 }
5954
5955 let next_out_of_line = decoder.next_out_of_line();
5956 let handles_before = decoder.remaining_handles();
5957 if let Some((inlined, num_bytes, num_handles)) =
5958 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5959 {
5960 let member_inline_size =
5961 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5962 if inlined != (member_inline_size <= 4) {
5963 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5964 }
5965 let inner_offset;
5966 let mut inner_depth = depth.clone();
5967 if inlined {
5968 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5969 inner_offset = next_offset;
5970 } else {
5971 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5972 inner_depth.increment()?;
5973 }
5974 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
5975 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5976 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5977 {
5978 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5979 }
5980 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5981 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5982 }
5983 }
5984
5985 next_offset += envelope_size;
5986 _next_ordinal_to_read += 1;
5987 if next_offset >= end_offset {
5988 return Ok(());
5989 }
5990
5991 while _next_ordinal_to_read < 2 {
5993 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5994 _next_ordinal_to_read += 1;
5995 next_offset += envelope_size;
5996 }
5997
5998 let next_out_of_line = decoder.next_out_of_line();
5999 let handles_before = decoder.remaining_handles();
6000 if let Some((inlined, num_bytes, num_handles)) =
6001 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6002 {
6003 let member_inline_size = <fidl::encoding::Vector<
6004 fidl::encoding::Vector<u8, 255>,
6005 256,
6006 > as fidl::encoding::TypeMarker>::inline_size(
6007 decoder.context
6008 );
6009 if inlined != (member_inline_size <= 4) {
6010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6011 }
6012 let inner_offset;
6013 let mut inner_depth = depth.clone();
6014 if inlined {
6015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6016 inner_offset = next_offset;
6017 } else {
6018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6019 inner_depth.increment()?;
6020 }
6021 let val_ref = self.text.get_or_insert_with(|| {
6022 fidl::new_empty!(
6023 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
6024 D
6025 )
6026 });
6027 fidl::decode!(
6028 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
6029 D,
6030 val_ref,
6031 decoder,
6032 inner_offset,
6033 inner_depth
6034 )?;
6035 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6036 {
6037 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6038 }
6039 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6040 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6041 }
6042 }
6043
6044 next_offset += envelope_size;
6045 _next_ordinal_to_read += 1;
6046 if next_offset >= end_offset {
6047 return Ok(());
6048 }
6049
6050 while _next_ordinal_to_read < 3 {
6052 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6053 _next_ordinal_to_read += 1;
6054 next_offset += envelope_size;
6055 }
6056
6057 let next_out_of_line = decoder.next_out_of_line();
6058 let handles_before = decoder.remaining_handles();
6059 if let Some((inlined, num_bytes, num_handles)) =
6060 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6061 {
6062 let member_inline_size =
6063 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6064 if inlined != (member_inline_size <= 4) {
6065 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6066 }
6067 let inner_offset;
6068 let mut inner_depth = depth.clone();
6069 if inlined {
6070 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6071 inner_offset = next_offset;
6072 } else {
6073 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6074 inner_depth.increment()?;
6075 }
6076 let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
6077 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6078 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6079 {
6080 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6081 }
6082 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6083 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6084 }
6085 }
6086
6087 next_offset += envelope_size;
6088 _next_ordinal_to_read += 1;
6089 if next_offset >= end_offset {
6090 return Ok(());
6091 }
6092
6093 while _next_ordinal_to_read < 4 {
6095 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6096 _next_ordinal_to_read += 1;
6097 next_offset += envelope_size;
6098 }
6099
6100 let next_out_of_line = decoder.next_out_of_line();
6101 let handles_before = decoder.remaining_handles();
6102 if let Some((inlined, num_bytes, num_handles)) =
6103 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6104 {
6105 let member_inline_size =
6106 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6107 if inlined != (member_inline_size <= 4) {
6108 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6109 }
6110 let inner_offset;
6111 let mut inner_depth = depth.clone();
6112 if inlined {
6113 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6114 inner_offset = next_offset;
6115 } else {
6116 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6117 inner_depth.increment()?;
6118 }
6119 let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
6120 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6121 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6122 {
6123 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6124 }
6125 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6126 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6127 }
6128 }
6129
6130 next_offset += envelope_size;
6131 _next_ordinal_to_read += 1;
6132 if next_offset >= end_offset {
6133 return Ok(());
6134 }
6135
6136 while _next_ordinal_to_read < 5 {
6138 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6139 _next_ordinal_to_read += 1;
6140 next_offset += envelope_size;
6141 }
6142
6143 let next_out_of_line = decoder.next_out_of_line();
6144 let handles_before = decoder.remaining_handles();
6145 if let Some((inlined, num_bytes, num_handles)) =
6146 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6147 {
6148 let member_inline_size =
6149 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6150 if inlined != (member_inline_size <= 4) {
6151 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6152 }
6153 let inner_offset;
6154 let mut inner_depth = depth.clone();
6155 if inlined {
6156 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6157 inner_offset = next_offset;
6158 } else {
6159 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6160 inner_depth.increment()?;
6161 }
6162 let val_ref = self.ptr_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6163 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6164 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6165 {
6166 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6167 }
6168 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6169 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6170 }
6171 }
6172
6173 next_offset += envelope_size;
6174 _next_ordinal_to_read += 1;
6175 if next_offset >= end_offset {
6176 return Ok(());
6177 }
6178
6179 while _next_ordinal_to_read < 6 {
6181 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6182 _next_ordinal_to_read += 1;
6183 next_offset += envelope_size;
6184 }
6185
6186 let next_out_of_line = decoder.next_out_of_line();
6187 let handles_before = decoder.remaining_handles();
6188 if let Some((inlined, num_bytes, num_handles)) =
6189 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6190 {
6191 let member_inline_size =
6192 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6193 if inlined != (member_inline_size <= 4) {
6194 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6195 }
6196 let inner_offset;
6197 let mut inner_depth = depth.clone();
6198 if inlined {
6199 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6200 inner_offset = next_offset;
6201 } else {
6202 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6203 inner_depth.increment()?;
6204 }
6205 let val_ref = self.srv_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6206 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6208 {
6209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6210 }
6211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6213 }
6214 }
6215
6216 next_offset += envelope_size;
6217 _next_ordinal_to_read += 1;
6218 if next_offset >= end_offset {
6219 return Ok(());
6220 }
6221
6222 while _next_ordinal_to_read < 7 {
6224 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6225 _next_ordinal_to_read += 1;
6226 next_offset += envelope_size;
6227 }
6228
6229 let next_out_of_line = decoder.next_out_of_line();
6230 let handles_before = decoder.remaining_handles();
6231 if let Some((inlined, num_bytes, num_handles)) =
6232 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6233 {
6234 let member_inline_size =
6235 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6236 if inlined != (member_inline_size <= 4) {
6237 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6238 }
6239 let inner_offset;
6240 let mut inner_depth = depth.clone();
6241 if inlined {
6242 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6243 inner_offset = next_offset;
6244 } else {
6245 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6246 inner_depth.increment()?;
6247 }
6248 let val_ref = self.txt_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6249 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6250 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6251 {
6252 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6253 }
6254 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6255 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6256 }
6257 }
6258
6259 next_offset += envelope_size;
6260
6261 while next_offset < end_offset {
6263 _next_ordinal_to_read += 1;
6264 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6265 next_offset += envelope_size;
6266 }
6267
6268 Ok(())
6269 }
6270 }
6271
6272 impl ServiceInstancePublicationOptions {
6273 #[inline(always)]
6274 fn max_ordinal_present(&self) -> u64 {
6275 if let Some(_) = self.perform_probe {
6276 return 3;
6277 }
6278 if let Some(_) = self.ip_versions {
6279 return 2;
6280 }
6281 if let Some(_) = self.media {
6282 return 1;
6283 }
6284 0
6285 }
6286 }
6287
6288 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationOptions {
6289 type Borrowed<'a> = &'a Self;
6290 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6291 value
6292 }
6293 }
6294
6295 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationOptions {
6296 type Owned = Self;
6297
6298 #[inline(always)]
6299 fn inline_align(_context: fidl::encoding::Context) -> usize {
6300 8
6301 }
6302
6303 #[inline(always)]
6304 fn inline_size(_context: fidl::encoding::Context) -> usize {
6305 16
6306 }
6307 }
6308
6309 unsafe impl<D: fidl::encoding::ResourceDialect>
6310 fidl::encoding::Encode<ServiceInstancePublicationOptions, D>
6311 for &ServiceInstancePublicationOptions
6312 {
6313 unsafe fn encode(
6314 self,
6315 encoder: &mut fidl::encoding::Encoder<'_, D>,
6316 offset: usize,
6317 mut depth: fidl::encoding::Depth,
6318 ) -> fidl::Result<()> {
6319 encoder.debug_check_bounds::<ServiceInstancePublicationOptions>(offset);
6320 let max_ordinal: u64 = self.max_ordinal_present();
6322 encoder.write_num(max_ordinal, offset);
6323 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6324 if max_ordinal == 0 {
6326 return Ok(());
6327 }
6328 depth.increment()?;
6329 let envelope_size = 8;
6330 let bytes_len = max_ordinal as usize * envelope_size;
6331 #[allow(unused_variables)]
6332 let offset = encoder.out_of_line_offset(bytes_len);
6333 let mut _prev_end_offset: usize = 0;
6334 if 1 > max_ordinal {
6335 return Ok(());
6336 }
6337
6338 let cur_offset: usize = (1 - 1) * envelope_size;
6341
6342 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6344
6345 fidl::encoding::encode_in_envelope_optional::<Media, D>(
6350 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6351 encoder,
6352 offset + cur_offset,
6353 depth,
6354 )?;
6355
6356 _prev_end_offset = cur_offset + envelope_size;
6357 if 2 > max_ordinal {
6358 return Ok(());
6359 }
6360
6361 let cur_offset: usize = (2 - 1) * envelope_size;
6364
6365 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6367
6368 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6373 self.ip_versions
6374 .as_ref()
6375 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6376 encoder,
6377 offset + cur_offset,
6378 depth,
6379 )?;
6380
6381 _prev_end_offset = cur_offset + envelope_size;
6382 if 3 > max_ordinal {
6383 return Ok(());
6384 }
6385
6386 let cur_offset: usize = (3 - 1) * envelope_size;
6389
6390 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6392
6393 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6398 self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6399 encoder,
6400 offset + cur_offset,
6401 depth,
6402 )?;
6403
6404 _prev_end_offset = cur_offset + envelope_size;
6405
6406 Ok(())
6407 }
6408 }
6409
6410 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6411 for ServiceInstancePublicationOptions
6412 {
6413 #[inline(always)]
6414 fn new_empty() -> Self {
6415 Self::default()
6416 }
6417
6418 unsafe fn decode(
6419 &mut self,
6420 decoder: &mut fidl::encoding::Decoder<'_, D>,
6421 offset: usize,
6422 mut depth: fidl::encoding::Depth,
6423 ) -> fidl::Result<()> {
6424 decoder.debug_check_bounds::<Self>(offset);
6425 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6426 None => return Err(fidl::Error::NotNullable),
6427 Some(len) => len,
6428 };
6429 if len == 0 {
6431 return Ok(());
6432 };
6433 depth.increment()?;
6434 let envelope_size = 8;
6435 let bytes_len = len * envelope_size;
6436 let offset = decoder.out_of_line_offset(bytes_len)?;
6437 let mut _next_ordinal_to_read = 0;
6439 let mut next_offset = offset;
6440 let end_offset = offset + bytes_len;
6441 _next_ordinal_to_read += 1;
6442 if next_offset >= end_offset {
6443 return Ok(());
6444 }
6445
6446 while _next_ordinal_to_read < 1 {
6448 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6449 _next_ordinal_to_read += 1;
6450 next_offset += envelope_size;
6451 }
6452
6453 let next_out_of_line = decoder.next_out_of_line();
6454 let handles_before = decoder.remaining_handles();
6455 if let Some((inlined, num_bytes, num_handles)) =
6456 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6457 {
6458 let member_inline_size =
6459 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6460 if inlined != (member_inline_size <= 4) {
6461 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6462 }
6463 let inner_offset;
6464 let mut inner_depth = depth.clone();
6465 if inlined {
6466 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6467 inner_offset = next_offset;
6468 } else {
6469 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6470 inner_depth.increment()?;
6471 }
6472 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6473 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6474 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6475 {
6476 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6477 }
6478 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6479 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6480 }
6481 }
6482
6483 next_offset += envelope_size;
6484 _next_ordinal_to_read += 1;
6485 if next_offset >= end_offset {
6486 return Ok(());
6487 }
6488
6489 while _next_ordinal_to_read < 2 {
6491 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6492 _next_ordinal_to_read += 1;
6493 next_offset += envelope_size;
6494 }
6495
6496 let next_out_of_line = decoder.next_out_of_line();
6497 let handles_before = decoder.remaining_handles();
6498 if let Some((inlined, num_bytes, num_handles)) =
6499 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6500 {
6501 let member_inline_size =
6502 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6503 if inlined != (member_inline_size <= 4) {
6504 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6505 }
6506 let inner_offset;
6507 let mut inner_depth = depth.clone();
6508 if inlined {
6509 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6510 inner_offset = next_offset;
6511 } else {
6512 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6513 inner_depth.increment()?;
6514 }
6515 let val_ref =
6516 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6517 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6518 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6519 {
6520 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6521 }
6522 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6523 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6524 }
6525 }
6526
6527 next_offset += envelope_size;
6528 _next_ordinal_to_read += 1;
6529 if next_offset >= end_offset {
6530 return Ok(());
6531 }
6532
6533 while _next_ordinal_to_read < 3 {
6535 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6536 _next_ordinal_to_read += 1;
6537 next_offset += envelope_size;
6538 }
6539
6540 let next_out_of_line = decoder.next_out_of_line();
6541 let handles_before = decoder.remaining_handles();
6542 if let Some((inlined, num_bytes, num_handles)) =
6543 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6544 {
6545 let member_inline_size =
6546 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6547 if inlined != (member_inline_size <= 4) {
6548 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6549 }
6550 let inner_offset;
6551 let mut inner_depth = depth.clone();
6552 if inlined {
6553 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6554 inner_offset = next_offset;
6555 } else {
6556 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6557 inner_depth.increment()?;
6558 }
6559 let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
6560 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6561 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6562 {
6563 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6564 }
6565 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6566 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6567 }
6568 }
6569
6570 next_offset += envelope_size;
6571
6572 while next_offset < end_offset {
6574 _next_ordinal_to_read += 1;
6575 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6576 next_offset += envelope_size;
6577 }
6578
6579 Ok(())
6580 }
6581 }
6582
6583 impl ServiceInstanceResolutionOptions {
6584 #[inline(always)]
6585 fn max_ordinal_present(&self) -> u64 {
6586 if let Some(_) = self.exclude_local_proxies {
6587 return 4;
6588 }
6589 if let Some(_) = self.exclude_local {
6590 return 3;
6591 }
6592 if let Some(_) = self.ip_versions {
6593 return 2;
6594 }
6595 if let Some(_) = self.media {
6596 return 1;
6597 }
6598 0
6599 }
6600 }
6601
6602 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolutionOptions {
6603 type Borrowed<'a> = &'a Self;
6604 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6605 value
6606 }
6607 }
6608
6609 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolutionOptions {
6610 type Owned = Self;
6611
6612 #[inline(always)]
6613 fn inline_align(_context: fidl::encoding::Context) -> usize {
6614 8
6615 }
6616
6617 #[inline(always)]
6618 fn inline_size(_context: fidl::encoding::Context) -> usize {
6619 16
6620 }
6621 }
6622
6623 unsafe impl<D: fidl::encoding::ResourceDialect>
6624 fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>
6625 for &ServiceInstanceResolutionOptions
6626 {
6627 unsafe fn encode(
6628 self,
6629 encoder: &mut fidl::encoding::Encoder<'_, D>,
6630 offset: usize,
6631 mut depth: fidl::encoding::Depth,
6632 ) -> fidl::Result<()> {
6633 encoder.debug_check_bounds::<ServiceInstanceResolutionOptions>(offset);
6634 let max_ordinal: u64 = self.max_ordinal_present();
6636 encoder.write_num(max_ordinal, offset);
6637 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6638 if max_ordinal == 0 {
6640 return Ok(());
6641 }
6642 depth.increment()?;
6643 let envelope_size = 8;
6644 let bytes_len = max_ordinal as usize * envelope_size;
6645 #[allow(unused_variables)]
6646 let offset = encoder.out_of_line_offset(bytes_len);
6647 let mut _prev_end_offset: usize = 0;
6648 if 1 > max_ordinal {
6649 return Ok(());
6650 }
6651
6652 let cur_offset: usize = (1 - 1) * envelope_size;
6655
6656 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6658
6659 fidl::encoding::encode_in_envelope_optional::<Media, D>(
6664 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6665 encoder,
6666 offset + cur_offset,
6667 depth,
6668 )?;
6669
6670 _prev_end_offset = cur_offset + envelope_size;
6671 if 2 > max_ordinal {
6672 return Ok(());
6673 }
6674
6675 let cur_offset: usize = (2 - 1) * envelope_size;
6678
6679 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6681
6682 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6687 self.ip_versions
6688 .as_ref()
6689 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6690 encoder,
6691 offset + cur_offset,
6692 depth,
6693 )?;
6694
6695 _prev_end_offset = cur_offset + envelope_size;
6696 if 3 > max_ordinal {
6697 return Ok(());
6698 }
6699
6700 let cur_offset: usize = (3 - 1) * envelope_size;
6703
6704 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6706
6707 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6712 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6713 encoder,
6714 offset + cur_offset,
6715 depth,
6716 )?;
6717
6718 _prev_end_offset = cur_offset + envelope_size;
6719 if 4 > max_ordinal {
6720 return Ok(());
6721 }
6722
6723 let cur_offset: usize = (4 - 1) * envelope_size;
6726
6727 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6729
6730 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6735 self.exclude_local_proxies
6736 .as_ref()
6737 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6738 encoder,
6739 offset + cur_offset,
6740 depth,
6741 )?;
6742
6743 _prev_end_offset = cur_offset + envelope_size;
6744
6745 Ok(())
6746 }
6747 }
6748
6749 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6750 for ServiceInstanceResolutionOptions
6751 {
6752 #[inline(always)]
6753 fn new_empty() -> Self {
6754 Self::default()
6755 }
6756
6757 unsafe fn decode(
6758 &mut self,
6759 decoder: &mut fidl::encoding::Decoder<'_, D>,
6760 offset: usize,
6761 mut depth: fidl::encoding::Depth,
6762 ) -> fidl::Result<()> {
6763 decoder.debug_check_bounds::<Self>(offset);
6764 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6765 None => return Err(fidl::Error::NotNullable),
6766 Some(len) => len,
6767 };
6768 if len == 0 {
6770 return Ok(());
6771 };
6772 depth.increment()?;
6773 let envelope_size = 8;
6774 let bytes_len = len * envelope_size;
6775 let offset = decoder.out_of_line_offset(bytes_len)?;
6776 let mut _next_ordinal_to_read = 0;
6778 let mut next_offset = offset;
6779 let end_offset = offset + bytes_len;
6780 _next_ordinal_to_read += 1;
6781 if next_offset >= end_offset {
6782 return Ok(());
6783 }
6784
6785 while _next_ordinal_to_read < 1 {
6787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6788 _next_ordinal_to_read += 1;
6789 next_offset += envelope_size;
6790 }
6791
6792 let next_out_of_line = decoder.next_out_of_line();
6793 let handles_before = decoder.remaining_handles();
6794 if let Some((inlined, num_bytes, num_handles)) =
6795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6796 {
6797 let member_inline_size =
6798 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6799 if inlined != (member_inline_size <= 4) {
6800 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6801 }
6802 let inner_offset;
6803 let mut inner_depth = depth.clone();
6804 if inlined {
6805 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6806 inner_offset = next_offset;
6807 } else {
6808 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6809 inner_depth.increment()?;
6810 }
6811 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6812 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6813 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6814 {
6815 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6816 }
6817 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6818 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6819 }
6820 }
6821
6822 next_offset += envelope_size;
6823 _next_ordinal_to_read += 1;
6824 if next_offset >= end_offset {
6825 return Ok(());
6826 }
6827
6828 while _next_ordinal_to_read < 2 {
6830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6831 _next_ordinal_to_read += 1;
6832 next_offset += envelope_size;
6833 }
6834
6835 let next_out_of_line = decoder.next_out_of_line();
6836 let handles_before = decoder.remaining_handles();
6837 if let Some((inlined, num_bytes, num_handles)) =
6838 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6839 {
6840 let member_inline_size =
6841 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6842 if inlined != (member_inline_size <= 4) {
6843 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6844 }
6845 let inner_offset;
6846 let mut inner_depth = depth.clone();
6847 if inlined {
6848 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6849 inner_offset = next_offset;
6850 } else {
6851 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6852 inner_depth.increment()?;
6853 }
6854 let val_ref =
6855 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6856 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6857 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6858 {
6859 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6860 }
6861 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6862 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6863 }
6864 }
6865
6866 next_offset += envelope_size;
6867 _next_ordinal_to_read += 1;
6868 if next_offset >= end_offset {
6869 return Ok(());
6870 }
6871
6872 while _next_ordinal_to_read < 3 {
6874 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6875 _next_ordinal_to_read += 1;
6876 next_offset += envelope_size;
6877 }
6878
6879 let next_out_of_line = decoder.next_out_of_line();
6880 let handles_before = decoder.remaining_handles();
6881 if let Some((inlined, num_bytes, num_handles)) =
6882 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6883 {
6884 let member_inline_size =
6885 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6886 if inlined != (member_inline_size <= 4) {
6887 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6888 }
6889 let inner_offset;
6890 let mut inner_depth = depth.clone();
6891 if inlined {
6892 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6893 inner_offset = next_offset;
6894 } else {
6895 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6896 inner_depth.increment()?;
6897 }
6898 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
6899 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6901 {
6902 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6903 }
6904 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6905 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6906 }
6907 }
6908
6909 next_offset += envelope_size;
6910 _next_ordinal_to_read += 1;
6911 if next_offset >= end_offset {
6912 return Ok(());
6913 }
6914
6915 while _next_ordinal_to_read < 4 {
6917 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6918 _next_ordinal_to_read += 1;
6919 next_offset += envelope_size;
6920 }
6921
6922 let next_out_of_line = decoder.next_out_of_line();
6923 let handles_before = decoder.remaining_handles();
6924 if let Some((inlined, num_bytes, num_handles)) =
6925 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6926 {
6927 let member_inline_size =
6928 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6929 if inlined != (member_inline_size <= 4) {
6930 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6931 }
6932 let inner_offset;
6933 let mut inner_depth = depth.clone();
6934 if inlined {
6935 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6936 inner_offset = next_offset;
6937 } else {
6938 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6939 inner_depth.increment()?;
6940 }
6941 let val_ref =
6942 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
6943 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6944 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6945 {
6946 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6947 }
6948 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6949 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6950 }
6951 }
6952
6953 next_offset += envelope_size;
6954
6955 while next_offset < end_offset {
6957 _next_ordinal_to_read += 1;
6958 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6959 next_offset += envelope_size;
6960 }
6961
6962 Ok(())
6963 }
6964 }
6965
6966 impl ServiceSubscriptionOptions {
6967 #[inline(always)]
6968 fn max_ordinal_present(&self) -> u64 {
6969 if let Some(_) = self.exclude_local_proxies {
6970 return 4;
6971 }
6972 if let Some(_) = self.exclude_local {
6973 return 3;
6974 }
6975 if let Some(_) = self.ip_versions {
6976 return 2;
6977 }
6978 if let Some(_) = self.media {
6979 return 1;
6980 }
6981 0
6982 }
6983 }
6984
6985 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionOptions {
6986 type Borrowed<'a> = &'a Self;
6987 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6988 value
6989 }
6990 }
6991
6992 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionOptions {
6993 type Owned = Self;
6994
6995 #[inline(always)]
6996 fn inline_align(_context: fidl::encoding::Context) -> usize {
6997 8
6998 }
6999
7000 #[inline(always)]
7001 fn inline_size(_context: fidl::encoding::Context) -> usize {
7002 16
7003 }
7004 }
7005
7006 unsafe impl<D: fidl::encoding::ResourceDialect>
7007 fidl::encoding::Encode<ServiceSubscriptionOptions, D> for &ServiceSubscriptionOptions
7008 {
7009 unsafe fn encode(
7010 self,
7011 encoder: &mut fidl::encoding::Encoder<'_, D>,
7012 offset: usize,
7013 mut depth: fidl::encoding::Depth,
7014 ) -> fidl::Result<()> {
7015 encoder.debug_check_bounds::<ServiceSubscriptionOptions>(offset);
7016 let max_ordinal: u64 = self.max_ordinal_present();
7018 encoder.write_num(max_ordinal, offset);
7019 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7020 if max_ordinal == 0 {
7022 return Ok(());
7023 }
7024 depth.increment()?;
7025 let envelope_size = 8;
7026 let bytes_len = max_ordinal as usize * envelope_size;
7027 #[allow(unused_variables)]
7028 let offset = encoder.out_of_line_offset(bytes_len);
7029 let mut _prev_end_offset: usize = 0;
7030 if 1 > max_ordinal {
7031 return Ok(());
7032 }
7033
7034 let cur_offset: usize = (1 - 1) * envelope_size;
7037
7038 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7040
7041 fidl::encoding::encode_in_envelope_optional::<Media, D>(
7046 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
7047 encoder,
7048 offset + cur_offset,
7049 depth,
7050 )?;
7051
7052 _prev_end_offset = cur_offset + envelope_size;
7053 if 2 > max_ordinal {
7054 return Ok(());
7055 }
7056
7057 let cur_offset: usize = (2 - 1) * envelope_size;
7060
7061 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7063
7064 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
7069 self.ip_versions
7070 .as_ref()
7071 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
7072 encoder,
7073 offset + cur_offset,
7074 depth,
7075 )?;
7076
7077 _prev_end_offset = cur_offset + envelope_size;
7078 if 3 > max_ordinal {
7079 return Ok(());
7080 }
7081
7082 let cur_offset: usize = (3 - 1) * envelope_size;
7085
7086 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7088
7089 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7094 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7095 encoder,
7096 offset + cur_offset,
7097 depth,
7098 )?;
7099
7100 _prev_end_offset = cur_offset + envelope_size;
7101 if 4 > max_ordinal {
7102 return Ok(());
7103 }
7104
7105 let cur_offset: usize = (4 - 1) * envelope_size;
7108
7109 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7111
7112 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7117 self.exclude_local_proxies
7118 .as_ref()
7119 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7120 encoder,
7121 offset + cur_offset,
7122 depth,
7123 )?;
7124
7125 _prev_end_offset = cur_offset + envelope_size;
7126
7127 Ok(())
7128 }
7129 }
7130
7131 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7132 for ServiceSubscriptionOptions
7133 {
7134 #[inline(always)]
7135 fn new_empty() -> Self {
7136 Self::default()
7137 }
7138
7139 unsafe fn decode(
7140 &mut self,
7141 decoder: &mut fidl::encoding::Decoder<'_, D>,
7142 offset: usize,
7143 mut depth: fidl::encoding::Depth,
7144 ) -> fidl::Result<()> {
7145 decoder.debug_check_bounds::<Self>(offset);
7146 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7147 None => return Err(fidl::Error::NotNullable),
7148 Some(len) => len,
7149 };
7150 if len == 0 {
7152 return Ok(());
7153 };
7154 depth.increment()?;
7155 let envelope_size = 8;
7156 let bytes_len = len * envelope_size;
7157 let offset = decoder.out_of_line_offset(bytes_len)?;
7158 let mut _next_ordinal_to_read = 0;
7160 let mut next_offset = offset;
7161 let end_offset = offset + bytes_len;
7162 _next_ordinal_to_read += 1;
7163 if next_offset >= end_offset {
7164 return Ok(());
7165 }
7166
7167 while _next_ordinal_to_read < 1 {
7169 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7170 _next_ordinal_to_read += 1;
7171 next_offset += envelope_size;
7172 }
7173
7174 let next_out_of_line = decoder.next_out_of_line();
7175 let handles_before = decoder.remaining_handles();
7176 if let Some((inlined, num_bytes, num_handles)) =
7177 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7178 {
7179 let member_inline_size =
7180 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7181 if inlined != (member_inline_size <= 4) {
7182 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7183 }
7184 let inner_offset;
7185 let mut inner_depth = depth.clone();
7186 if inlined {
7187 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7188 inner_offset = next_offset;
7189 } else {
7190 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7191 inner_depth.increment()?;
7192 }
7193 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
7194 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
7195 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7196 {
7197 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7198 }
7199 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7200 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7201 }
7202 }
7203
7204 next_offset += envelope_size;
7205 _next_ordinal_to_read += 1;
7206 if next_offset >= end_offset {
7207 return Ok(());
7208 }
7209
7210 while _next_ordinal_to_read < 2 {
7212 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7213 _next_ordinal_to_read += 1;
7214 next_offset += envelope_size;
7215 }
7216
7217 let next_out_of_line = decoder.next_out_of_line();
7218 let handles_before = decoder.remaining_handles();
7219 if let Some((inlined, num_bytes, num_handles)) =
7220 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7221 {
7222 let member_inline_size =
7223 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7224 if inlined != (member_inline_size <= 4) {
7225 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7226 }
7227 let inner_offset;
7228 let mut inner_depth = depth.clone();
7229 if inlined {
7230 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7231 inner_offset = next_offset;
7232 } else {
7233 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7234 inner_depth.increment()?;
7235 }
7236 let val_ref =
7237 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
7238 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
7239 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7240 {
7241 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7242 }
7243 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7244 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7245 }
7246 }
7247
7248 next_offset += envelope_size;
7249 _next_ordinal_to_read += 1;
7250 if next_offset >= end_offset {
7251 return Ok(());
7252 }
7253
7254 while _next_ordinal_to_read < 3 {
7256 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7257 _next_ordinal_to_read += 1;
7258 next_offset += envelope_size;
7259 }
7260
7261 let next_out_of_line = decoder.next_out_of_line();
7262 let handles_before = decoder.remaining_handles();
7263 if let Some((inlined, num_bytes, num_handles)) =
7264 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7265 {
7266 let member_inline_size =
7267 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7268 if inlined != (member_inline_size <= 4) {
7269 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7270 }
7271 let inner_offset;
7272 let mut inner_depth = depth.clone();
7273 if inlined {
7274 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7275 inner_offset = next_offset;
7276 } else {
7277 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7278 inner_depth.increment()?;
7279 }
7280 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
7281 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7282 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7283 {
7284 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7285 }
7286 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7287 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7288 }
7289 }
7290
7291 next_offset += envelope_size;
7292 _next_ordinal_to_read += 1;
7293 if next_offset >= end_offset {
7294 return Ok(());
7295 }
7296
7297 while _next_ordinal_to_read < 4 {
7299 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7300 _next_ordinal_to_read += 1;
7301 next_offset += envelope_size;
7302 }
7303
7304 let next_out_of_line = decoder.next_out_of_line();
7305 let handles_before = decoder.remaining_handles();
7306 if let Some((inlined, num_bytes, num_handles)) =
7307 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7308 {
7309 let member_inline_size =
7310 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7311 if inlined != (member_inline_size <= 4) {
7312 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7313 }
7314 let inner_offset;
7315 let mut inner_depth = depth.clone();
7316 if inlined {
7317 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7318 inner_offset = next_offset;
7319 } else {
7320 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7321 inner_depth.increment()?;
7322 }
7323 let val_ref =
7324 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
7325 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7326 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7327 {
7328 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7329 }
7330 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7331 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7332 }
7333 }
7334
7335 next_offset += envelope_size;
7336
7337 while next_offset < end_offset {
7339 _next_ordinal_to_read += 1;
7340 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7341 next_offset += envelope_size;
7342 }
7343
7344 Ok(())
7345 }
7346 }
7347}