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
704mod internal {
705 use super::*;
706 unsafe impl fidl::encoding::TypeMarker for IpVersions {
707 type Owned = Self;
708
709 #[inline(always)]
710 fn inline_align(_context: fidl::encoding::Context) -> usize {
711 4
712 }
713
714 #[inline(always)]
715 fn inline_size(_context: fidl::encoding::Context) -> usize {
716 4
717 }
718 }
719
720 impl fidl::encoding::ValueTypeMarker for IpVersions {
721 type Borrowed<'a> = Self;
722 #[inline(always)]
723 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
724 *value
725 }
726 }
727
728 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IpVersions {
729 #[inline]
730 unsafe fn encode(
731 self,
732 encoder: &mut fidl::encoding::Encoder<'_, D>,
733 offset: usize,
734 _depth: fidl::encoding::Depth,
735 ) -> fidl::Result<()> {
736 encoder.debug_check_bounds::<Self>(offset);
737 if self.bits() & Self::all().bits() != self.bits() {
738 return Err(fidl::Error::InvalidBitsValue);
739 }
740 encoder.write_num(self.bits(), offset);
741 Ok(())
742 }
743 }
744
745 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpVersions {
746 #[inline(always)]
747 fn new_empty() -> Self {
748 Self::empty()
749 }
750
751 #[inline]
752 unsafe fn decode(
753 &mut self,
754 decoder: &mut fidl::encoding::Decoder<'_, D>,
755 offset: usize,
756 _depth: fidl::encoding::Depth,
757 ) -> fidl::Result<()> {
758 decoder.debug_check_bounds::<Self>(offset);
759 let prim = decoder.read_num::<u32>(offset);
760 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
761 Ok(())
762 }
763 }
764 unsafe impl fidl::encoding::TypeMarker for Media {
765 type Owned = Self;
766
767 #[inline(always)]
768 fn inline_align(_context: fidl::encoding::Context) -> usize {
769 4
770 }
771
772 #[inline(always)]
773 fn inline_size(_context: fidl::encoding::Context) -> usize {
774 4
775 }
776 }
777
778 impl fidl::encoding::ValueTypeMarker for Media {
779 type Borrowed<'a> = Self;
780 #[inline(always)]
781 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
782 *value
783 }
784 }
785
786 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Media {
787 #[inline]
788 unsafe fn encode(
789 self,
790 encoder: &mut fidl::encoding::Encoder<'_, D>,
791 offset: usize,
792 _depth: fidl::encoding::Depth,
793 ) -> fidl::Result<()> {
794 encoder.debug_check_bounds::<Self>(offset);
795 if self.bits() & Self::all().bits() != self.bits() {
796 return Err(fidl::Error::InvalidBitsValue);
797 }
798 encoder.write_num(self.bits(), offset);
799 Ok(())
800 }
801 }
802
803 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Media {
804 #[inline(always)]
805 fn new_empty() -> Self {
806 Self::empty()
807 }
808
809 #[inline]
810 unsafe fn decode(
811 &mut self,
812 decoder: &mut fidl::encoding::Decoder<'_, D>,
813 offset: usize,
814 _depth: fidl::encoding::Depth,
815 ) -> fidl::Result<()> {
816 decoder.debug_check_bounds::<Self>(offset);
817 let prim = decoder.read_num::<u32>(offset);
818 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
819 Ok(())
820 }
821 }
822 unsafe impl fidl::encoding::TypeMarker for Error {
823 type Owned = Self;
824
825 #[inline(always)]
826 fn inline_align(_context: fidl::encoding::Context) -> usize {
827 std::mem::align_of::<u32>()
828 }
829
830 #[inline(always)]
831 fn inline_size(_context: fidl::encoding::Context) -> usize {
832 std::mem::size_of::<u32>()
833 }
834
835 #[inline(always)]
836 fn encode_is_copy() -> bool {
837 true
838 }
839
840 #[inline(always)]
841 fn decode_is_copy() -> bool {
842 false
843 }
844 }
845
846 impl fidl::encoding::ValueTypeMarker for Error {
847 type Borrowed<'a> = Self;
848 #[inline(always)]
849 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
850 *value
851 }
852 }
853
854 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Error {
855 #[inline]
856 unsafe fn encode(
857 self,
858 encoder: &mut fidl::encoding::Encoder<'_, D>,
859 offset: usize,
860 _depth: fidl::encoding::Depth,
861 ) -> fidl::Result<()> {
862 encoder.debug_check_bounds::<Self>(offset);
863 encoder.write_num(self.into_primitive(), offset);
864 Ok(())
865 }
866 }
867
868 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Error {
869 #[inline(always)]
870 fn new_empty() -> Self {
871 Self::InvalidServiceName
872 }
873
874 #[inline]
875 unsafe fn decode(
876 &mut self,
877 decoder: &mut fidl::encoding::Decoder<'_, D>,
878 offset: usize,
879 _depth: fidl::encoding::Depth,
880 ) -> fidl::Result<()> {
881 decoder.debug_check_bounds::<Self>(offset);
882 let prim = decoder.read_num::<u32>(offset);
883
884 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
885 Ok(())
886 }
887 }
888 unsafe impl fidl::encoding::TypeMarker for OnPublicationError {
889 type Owned = Self;
890
891 #[inline(always)]
892 fn inline_align(_context: fidl::encoding::Context) -> usize {
893 std::mem::align_of::<u32>()
894 }
895
896 #[inline(always)]
897 fn inline_size(_context: fidl::encoding::Context) -> usize {
898 std::mem::size_of::<u32>()
899 }
900
901 #[inline(always)]
902 fn encode_is_copy() -> bool {
903 true
904 }
905
906 #[inline(always)]
907 fn decode_is_copy() -> bool {
908 false
909 }
910 }
911
912 impl fidl::encoding::ValueTypeMarker for OnPublicationError {
913 type Borrowed<'a> = Self;
914 #[inline(always)]
915 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
916 *value
917 }
918 }
919
920 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
921 for OnPublicationError
922 {
923 #[inline]
924 unsafe fn encode(
925 self,
926 encoder: &mut fidl::encoding::Encoder<'_, D>,
927 offset: usize,
928 _depth: fidl::encoding::Depth,
929 ) -> fidl::Result<()> {
930 encoder.debug_check_bounds::<Self>(offset);
931 encoder.write_num(self.into_primitive(), offset);
932 Ok(())
933 }
934 }
935
936 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnPublicationError {
937 #[inline(always)]
938 fn new_empty() -> Self {
939 Self::DoNotRespond
940 }
941
942 #[inline]
943 unsafe fn decode(
944 &mut self,
945 decoder: &mut fidl::encoding::Decoder<'_, D>,
946 offset: usize,
947 _depth: fidl::encoding::Depth,
948 ) -> fidl::Result<()> {
949 decoder.debug_check_bounds::<Self>(offset);
950 let prim = decoder.read_num::<u32>(offset);
951
952 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
953 Ok(())
954 }
955 }
956 unsafe impl fidl::encoding::TypeMarker for PublicationCause {
957 type Owned = Self;
958
959 #[inline(always)]
960 fn inline_align(_context: fidl::encoding::Context) -> usize {
961 std::mem::align_of::<u32>()
962 }
963
964 #[inline(always)]
965 fn inline_size(_context: fidl::encoding::Context) -> usize {
966 std::mem::size_of::<u32>()
967 }
968
969 #[inline(always)]
970 fn encode_is_copy() -> bool {
971 true
972 }
973
974 #[inline(always)]
975 fn decode_is_copy() -> bool {
976 false
977 }
978 }
979
980 impl fidl::encoding::ValueTypeMarker for PublicationCause {
981 type Borrowed<'a> = Self;
982 #[inline(always)]
983 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
984 *value
985 }
986 }
987
988 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
989 for PublicationCause
990 {
991 #[inline]
992 unsafe fn encode(
993 self,
994 encoder: &mut fidl::encoding::Encoder<'_, D>,
995 offset: usize,
996 _depth: fidl::encoding::Depth,
997 ) -> fidl::Result<()> {
998 encoder.debug_check_bounds::<Self>(offset);
999 encoder.write_num(self.into_primitive(), offset);
1000 Ok(())
1001 }
1002 }
1003
1004 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublicationCause {
1005 #[inline(always)]
1006 fn new_empty() -> Self {
1007 Self::Announcement
1008 }
1009
1010 #[inline]
1011 unsafe fn decode(
1012 &mut self,
1013 decoder: &mut fidl::encoding::Decoder<'_, D>,
1014 offset: usize,
1015 _depth: fidl::encoding::Depth,
1016 ) -> fidl::Result<()> {
1017 decoder.debug_check_bounds::<Self>(offset);
1018 let prim = decoder.read_num::<u32>(offset);
1019
1020 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1021 Ok(())
1022 }
1023 }
1024 unsafe impl fidl::encoding::TypeMarker for PublishProxyHostError {
1025 type Owned = Self;
1026
1027 #[inline(always)]
1028 fn inline_align(_context: fidl::encoding::Context) -> usize {
1029 std::mem::align_of::<u32>()
1030 }
1031
1032 #[inline(always)]
1033 fn inline_size(_context: fidl::encoding::Context) -> usize {
1034 std::mem::size_of::<u32>()
1035 }
1036
1037 #[inline(always)]
1038 fn encode_is_copy() -> bool {
1039 false
1040 }
1041
1042 #[inline(always)]
1043 fn decode_is_copy() -> bool {
1044 false
1045 }
1046 }
1047
1048 impl fidl::encoding::ValueTypeMarker for PublishProxyHostError {
1049 type Borrowed<'a> = Self;
1050 #[inline(always)]
1051 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1052 *value
1053 }
1054 }
1055
1056 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1057 for PublishProxyHostError
1058 {
1059 #[inline]
1060 unsafe fn encode(
1061 self,
1062 encoder: &mut fidl::encoding::Encoder<'_, D>,
1063 offset: usize,
1064 _depth: fidl::encoding::Depth,
1065 ) -> fidl::Result<()> {
1066 encoder.debug_check_bounds::<Self>(offset);
1067 encoder.write_num(self.into_primitive(), offset);
1068 Ok(())
1069 }
1070 }
1071
1072 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PublishProxyHostError {
1073 #[inline(always)]
1074 fn new_empty() -> Self {
1075 Self::unknown()
1076 }
1077
1078 #[inline]
1079 unsafe fn decode(
1080 &mut self,
1081 decoder: &mut fidl::encoding::Decoder<'_, D>,
1082 offset: usize,
1083 _depth: fidl::encoding::Depth,
1084 ) -> fidl::Result<()> {
1085 decoder.debug_check_bounds::<Self>(offset);
1086 let prim = decoder.read_num::<u32>(offset);
1087
1088 *self = Self::from_primitive_allow_unknown(prim);
1089 Ok(())
1090 }
1091 }
1092 unsafe impl fidl::encoding::TypeMarker for PublishServiceInstanceError {
1093 type Owned = Self;
1094
1095 #[inline(always)]
1096 fn inline_align(_context: fidl::encoding::Context) -> usize {
1097 std::mem::align_of::<u32>()
1098 }
1099
1100 #[inline(always)]
1101 fn inline_size(_context: fidl::encoding::Context) -> usize {
1102 std::mem::size_of::<u32>()
1103 }
1104
1105 #[inline(always)]
1106 fn encode_is_copy() -> bool {
1107 true
1108 }
1109
1110 #[inline(always)]
1111 fn decode_is_copy() -> bool {
1112 false
1113 }
1114 }
1115
1116 impl fidl::encoding::ValueTypeMarker for PublishServiceInstanceError {
1117 type Borrowed<'a> = Self;
1118 #[inline(always)]
1119 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1120 *value
1121 }
1122 }
1123
1124 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1125 for PublishServiceInstanceError
1126 {
1127 #[inline]
1128 unsafe fn encode(
1129 self,
1130 encoder: &mut fidl::encoding::Encoder<'_, D>,
1131 offset: usize,
1132 _depth: fidl::encoding::Depth,
1133 ) -> fidl::Result<()> {
1134 encoder.debug_check_bounds::<Self>(offset);
1135 encoder.write_num(self.into_primitive(), offset);
1136 Ok(())
1137 }
1138 }
1139
1140 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1141 for PublishServiceInstanceError
1142 {
1143 #[inline(always)]
1144 fn new_empty() -> Self {
1145 Self::AlreadyPublishedLocally
1146 }
1147
1148 #[inline]
1149 unsafe fn decode(
1150 &mut self,
1151 decoder: &mut fidl::encoding::Decoder<'_, D>,
1152 offset: usize,
1153 _depth: fidl::encoding::Depth,
1154 ) -> fidl::Result<()> {
1155 decoder.debug_check_bounds::<Self>(offset);
1156 let prim = decoder.read_num::<u32>(offset);
1157
1158 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1159 Ok(())
1160 }
1161 }
1162 unsafe impl fidl::encoding::TypeMarker for ResourceType {
1163 type Owned = Self;
1164
1165 #[inline(always)]
1166 fn inline_align(_context: fidl::encoding::Context) -> usize {
1167 std::mem::align_of::<u32>()
1168 }
1169
1170 #[inline(always)]
1171 fn inline_size(_context: fidl::encoding::Context) -> usize {
1172 std::mem::size_of::<u32>()
1173 }
1174
1175 #[inline(always)]
1176 fn encode_is_copy() -> bool {
1177 true
1178 }
1179
1180 #[inline(always)]
1181 fn decode_is_copy() -> bool {
1182 false
1183 }
1184 }
1185
1186 impl fidl::encoding::ValueTypeMarker for ResourceType {
1187 type Borrowed<'a> = Self;
1188 #[inline(always)]
1189 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1190 *value
1191 }
1192 }
1193
1194 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResourceType {
1195 #[inline]
1196 unsafe fn encode(
1197 self,
1198 encoder: &mut fidl::encoding::Encoder<'_, D>,
1199 offset: usize,
1200 _depth: fidl::encoding::Depth,
1201 ) -> fidl::Result<()> {
1202 encoder.debug_check_bounds::<Self>(offset);
1203 encoder.write_num(self.into_primitive(), offset);
1204 Ok(())
1205 }
1206 }
1207
1208 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResourceType {
1209 #[inline(always)]
1210 fn new_empty() -> Self {
1211 Self::Ptr
1212 }
1213
1214 #[inline]
1215 unsafe fn decode(
1216 &mut self,
1217 decoder: &mut fidl::encoding::Decoder<'_, D>,
1218 offset: usize,
1219 _depth: fidl::encoding::Depth,
1220 ) -> fidl::Result<()> {
1221 decoder.debug_check_bounds::<Self>(offset);
1222 let prim = decoder.read_num::<u32>(offset);
1223
1224 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1225 Ok(())
1226 }
1227 }
1228 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationCause {
1229 type Owned = Self;
1230
1231 #[inline(always)]
1232 fn inline_align(_context: fidl::encoding::Context) -> usize {
1233 std::mem::align_of::<u32>()
1234 }
1235
1236 #[inline(always)]
1237 fn inline_size(_context: fidl::encoding::Context) -> usize {
1238 std::mem::size_of::<u32>()
1239 }
1240
1241 #[inline(always)]
1242 fn encode_is_copy() -> bool {
1243 true
1244 }
1245
1246 #[inline(always)]
1247 fn decode_is_copy() -> bool {
1248 false
1249 }
1250 }
1251
1252 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationCause {
1253 type Borrowed<'a> = Self;
1254 #[inline(always)]
1255 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1256 *value
1257 }
1258 }
1259
1260 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1261 for ServiceInstancePublicationCause
1262 {
1263 #[inline]
1264 unsafe fn encode(
1265 self,
1266 encoder: &mut fidl::encoding::Encoder<'_, D>,
1267 offset: usize,
1268 _depth: fidl::encoding::Depth,
1269 ) -> fidl::Result<()> {
1270 encoder.debug_check_bounds::<Self>(offset);
1271 encoder.write_num(self.into_primitive(), offset);
1272 Ok(())
1273 }
1274 }
1275
1276 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1277 for ServiceInstancePublicationCause
1278 {
1279 #[inline(always)]
1280 fn new_empty() -> Self {
1281 Self::Announcement
1282 }
1283
1284 #[inline]
1285 unsafe fn decode(
1286 &mut self,
1287 decoder: &mut fidl::encoding::Decoder<'_, D>,
1288 offset: usize,
1289 _depth: fidl::encoding::Depth,
1290 ) -> fidl::Result<()> {
1291 decoder.debug_check_bounds::<Self>(offset);
1292 let prim = decoder.read_num::<u32>(offset);
1293
1294 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1295 Ok(())
1296 }
1297 }
1298
1299 impl fidl::encoding::ValueTypeMarker for HostAddress {
1300 type Borrowed<'a> = &'a Self;
1301 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1302 value
1303 }
1304 }
1305
1306 unsafe impl fidl::encoding::TypeMarker for HostAddress {
1307 type Owned = Self;
1308
1309 #[inline(always)]
1310 fn inline_align(_context: fidl::encoding::Context) -> usize {
1311 8
1312 }
1313
1314 #[inline(always)]
1315 fn inline_size(_context: fidl::encoding::Context) -> usize {
1316 32
1317 }
1318 }
1319
1320 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<HostAddress, D>
1321 for &HostAddress
1322 {
1323 #[inline]
1324 unsafe fn encode(
1325 self,
1326 encoder: &mut fidl::encoding::Encoder<'_, D>,
1327 offset: usize,
1328 _depth: fidl::encoding::Depth,
1329 ) -> fidl::Result<()> {
1330 encoder.debug_check_bounds::<HostAddress>(offset);
1331 fidl::encoding::Encode::<HostAddress, D>::encode(
1333 (
1334 <fidl_fuchsia_net__common::IpAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1335 <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.interface),
1336 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ttl),
1337 ),
1338 encoder, offset, _depth
1339 )
1340 }
1341 }
1342 unsafe impl<
1343 D: fidl::encoding::ResourceDialect,
1344 T0: fidl::encoding::Encode<fidl_fuchsia_net__common::IpAddress, D>,
1345 T1: fidl::encoding::Encode<u64, D>,
1346 T2: fidl::encoding::Encode<i64, D>,
1347 > fidl::encoding::Encode<HostAddress, D> for (T0, T1, T2)
1348 {
1349 #[inline]
1350 unsafe fn encode(
1351 self,
1352 encoder: &mut fidl::encoding::Encoder<'_, D>,
1353 offset: usize,
1354 depth: fidl::encoding::Depth,
1355 ) -> fidl::Result<()> {
1356 encoder.debug_check_bounds::<HostAddress>(offset);
1357 self.0.encode(encoder, offset + 0, depth)?;
1361 self.1.encode(encoder, offset + 16, depth)?;
1362 self.2.encode(encoder, offset + 24, depth)?;
1363 Ok(())
1364 }
1365 }
1366
1367 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for HostAddress {
1368 #[inline(always)]
1369 fn new_empty() -> Self {
1370 Self {
1371 address: fidl::new_empty!(fidl_fuchsia_net__common::IpAddress, D),
1372 interface: fidl::new_empty!(u64, D),
1373 ttl: fidl::new_empty!(i64, D),
1374 }
1375 }
1376
1377 #[inline]
1378 unsafe fn decode(
1379 &mut self,
1380 decoder: &mut fidl::encoding::Decoder<'_, D>,
1381 offset: usize,
1382 _depth: fidl::encoding::Depth,
1383 ) -> fidl::Result<()> {
1384 decoder.debug_check_bounds::<Self>(offset);
1385 fidl::decode!(
1387 fidl_fuchsia_net__common::IpAddress,
1388 D,
1389 &mut self.address,
1390 decoder,
1391 offset + 0,
1392 _depth
1393 )?;
1394 fidl::decode!(u64, D, &mut self.interface, decoder, offset + 16, _depth)?;
1395 fidl::decode!(i64, D, &mut self.ttl, decoder, offset + 24, _depth)?;
1396 Ok(())
1397 }
1398 }
1399
1400 impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameRequest {
1401 type Borrowed<'a> = &'a Self;
1402 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1403 value
1404 }
1405 }
1406
1407 unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameRequest {
1408 type Owned = Self;
1409
1410 #[inline(always)]
1411 fn inline_align(_context: fidl::encoding::Context) -> usize {
1412 8
1413 }
1414
1415 #[inline(always)]
1416 fn inline_size(_context: fidl::encoding::Context) -> usize {
1417 40
1418 }
1419 }
1420
1421 unsafe impl<D: fidl::encoding::ResourceDialect>
1422 fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D>
1423 for &HostNameResolverResolveHostNameRequest
1424 {
1425 #[inline]
1426 unsafe fn encode(
1427 self,
1428 encoder: &mut fidl::encoding::Encoder<'_, D>,
1429 offset: usize,
1430 _depth: fidl::encoding::Depth,
1431 ) -> fidl::Result<()> {
1432 encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1433 fidl::encoding::Encode::<HostNameResolverResolveHostNameRequest, D>::encode(
1435 (
1436 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
1437 &self.host,
1438 ),
1439 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
1440 <HostNameResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(
1441 &self.options,
1442 ),
1443 ),
1444 encoder,
1445 offset,
1446 _depth,
1447 )
1448 }
1449 }
1450 unsafe impl<
1451 D: fidl::encoding::ResourceDialect,
1452 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
1453 T1: fidl::encoding::Encode<i64, D>,
1454 T2: fidl::encoding::Encode<HostNameResolutionOptions, D>,
1455 > fidl::encoding::Encode<HostNameResolverResolveHostNameRequest, D> for (T0, T1, T2)
1456 {
1457 #[inline]
1458 unsafe fn encode(
1459 self,
1460 encoder: &mut fidl::encoding::Encoder<'_, D>,
1461 offset: usize,
1462 depth: fidl::encoding::Depth,
1463 ) -> fidl::Result<()> {
1464 encoder.debug_check_bounds::<HostNameResolverResolveHostNameRequest>(offset);
1465 self.0.encode(encoder, offset + 0, depth)?;
1469 self.1.encode(encoder, offset + 16, depth)?;
1470 self.2.encode(encoder, offset + 24, depth)?;
1471 Ok(())
1472 }
1473 }
1474
1475 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1476 for HostNameResolverResolveHostNameRequest
1477 {
1478 #[inline(always)]
1479 fn new_empty() -> Self {
1480 Self {
1481 host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
1482 timeout: fidl::new_empty!(i64, D),
1483 options: fidl::new_empty!(HostNameResolutionOptions, D),
1484 }
1485 }
1486
1487 #[inline]
1488 unsafe fn decode(
1489 &mut self,
1490 decoder: &mut fidl::encoding::Decoder<'_, D>,
1491 offset: usize,
1492 _depth: fidl::encoding::Depth,
1493 ) -> fidl::Result<()> {
1494 decoder.debug_check_bounds::<Self>(offset);
1495 fidl::decode!(
1497 fidl::encoding::BoundedString<255>,
1498 D,
1499 &mut self.host,
1500 decoder,
1501 offset + 0,
1502 _depth
1503 )?;
1504 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
1505 fidl::decode!(
1506 HostNameResolutionOptions,
1507 D,
1508 &mut self.options,
1509 decoder,
1510 offset + 24,
1511 _depth
1512 )?;
1513 Ok(())
1514 }
1515 }
1516
1517 impl fidl::encoding::ValueTypeMarker for HostNameResolverResolveHostNameResponse {
1518 type Borrowed<'a> = &'a Self;
1519 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1520 value
1521 }
1522 }
1523
1524 unsafe impl fidl::encoding::TypeMarker for HostNameResolverResolveHostNameResponse {
1525 type Owned = Self;
1526
1527 #[inline(always)]
1528 fn inline_align(_context: fidl::encoding::Context) -> usize {
1529 8
1530 }
1531
1532 #[inline(always)]
1533 fn inline_size(_context: fidl::encoding::Context) -> usize {
1534 16
1535 }
1536 }
1537
1538 unsafe impl<D: fidl::encoding::ResourceDialect>
1539 fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D>
1540 for &HostNameResolverResolveHostNameResponse
1541 {
1542 #[inline]
1543 unsafe fn encode(
1544 self,
1545 encoder: &mut fidl::encoding::Encoder<'_, D>,
1546 offset: usize,
1547 _depth: fidl::encoding::Depth,
1548 ) -> fidl::Result<()> {
1549 encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1550 fidl::encoding::Encode::<HostNameResolverResolveHostNameResponse, D>::encode(
1552 (
1553 <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1554 ),
1555 encoder, offset, _depth
1556 )
1557 }
1558 }
1559 unsafe impl<
1560 D: fidl::encoding::ResourceDialect,
1561 T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1562 > fidl::encoding::Encode<HostNameResolverResolveHostNameResponse, D> for (T0,)
1563 {
1564 #[inline]
1565 unsafe fn encode(
1566 self,
1567 encoder: &mut fidl::encoding::Encoder<'_, D>,
1568 offset: usize,
1569 depth: fidl::encoding::Depth,
1570 ) -> fidl::Result<()> {
1571 encoder.debug_check_bounds::<HostNameResolverResolveHostNameResponse>(offset);
1572 self.0.encode(encoder, offset + 0, depth)?;
1576 Ok(())
1577 }
1578 }
1579
1580 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1581 for HostNameResolverResolveHostNameResponse
1582 {
1583 #[inline(always)]
1584 fn new_empty() -> Self {
1585 Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1586 }
1587
1588 #[inline]
1589 unsafe fn decode(
1590 &mut self,
1591 decoder: &mut fidl::encoding::Decoder<'_, D>,
1592 offset: usize,
1593 _depth: fidl::encoding::Depth,
1594 ) -> fidl::Result<()> {
1595 decoder.debug_check_bounds::<Self>(offset);
1596 fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1598 Ok(())
1599 }
1600 }
1601
1602 impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1603 type Borrowed<'a> = &'a Self;
1604 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1605 value
1606 }
1607 }
1608
1609 unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionListenerOnAddressesChangedRequest {
1610 type Owned = Self;
1611
1612 #[inline(always)]
1613 fn inline_align(_context: fidl::encoding::Context) -> usize {
1614 8
1615 }
1616
1617 #[inline(always)]
1618 fn inline_size(_context: fidl::encoding::Context) -> usize {
1619 16
1620 }
1621 }
1622
1623 unsafe impl<D: fidl::encoding::ResourceDialect>
1624 fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1625 for &HostNameSubscriptionListenerOnAddressesChangedRequest
1626 {
1627 #[inline]
1628 unsafe fn encode(
1629 self,
1630 encoder: &mut fidl::encoding::Encoder<'_, D>,
1631 offset: usize,
1632 _depth: fidl::encoding::Depth,
1633 ) -> fidl::Result<()> {
1634 encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1635 offset,
1636 );
1637 fidl::encoding::Encode::<HostNameSubscriptionListenerOnAddressesChangedRequest, D>::encode(
1639 (
1640 <fidl::encoding::Vector<HostAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.addresses),
1641 ),
1642 encoder, offset, _depth
1643 )
1644 }
1645 }
1646 unsafe impl<
1647 D: fidl::encoding::ResourceDialect,
1648 T0: fidl::encoding::Encode<fidl::encoding::Vector<HostAddress, 64>, D>,
1649 > fidl::encoding::Encode<HostNameSubscriptionListenerOnAddressesChangedRequest, D>
1650 for (T0,)
1651 {
1652 #[inline]
1653 unsafe fn encode(
1654 self,
1655 encoder: &mut fidl::encoding::Encoder<'_, D>,
1656 offset: usize,
1657 depth: fidl::encoding::Depth,
1658 ) -> fidl::Result<()> {
1659 encoder.debug_check_bounds::<HostNameSubscriptionListenerOnAddressesChangedRequest>(
1660 offset,
1661 );
1662 self.0.encode(encoder, offset + 0, depth)?;
1666 Ok(())
1667 }
1668 }
1669
1670 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1671 for HostNameSubscriptionListenerOnAddressesChangedRequest
1672 {
1673 #[inline(always)]
1674 fn new_empty() -> Self {
1675 Self { addresses: fidl::new_empty!(fidl::encoding::Vector<HostAddress, 64>, D) }
1676 }
1677
1678 #[inline]
1679 unsafe fn decode(
1680 &mut self,
1681 decoder: &mut fidl::encoding::Decoder<'_, D>,
1682 offset: usize,
1683 _depth: fidl::encoding::Depth,
1684 ) -> fidl::Result<()> {
1685 decoder.debug_check_bounds::<Self>(offset);
1686 fidl::decode!(fidl::encoding::Vector<HostAddress, 64>, D, &mut self.addresses, decoder, offset + 0, _depth)?;
1688 Ok(())
1689 }
1690 }
1691
1692 impl fidl::encoding::ValueTypeMarker for Publication {
1693 type Borrowed<'a> = &'a Self;
1694 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1695 value
1696 }
1697 }
1698
1699 unsafe impl fidl::encoding::TypeMarker for Publication {
1700 type Owned = Self;
1701
1702 #[inline(always)]
1703 fn inline_align(_context: fidl::encoding::Context) -> usize {
1704 8
1705 }
1706
1707 #[inline(always)]
1708 fn inline_size(_context: fidl::encoding::Context) -> usize {
1709 56
1710 }
1711 }
1712
1713 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Publication, D>
1714 for &Publication
1715 {
1716 #[inline]
1717 unsafe fn encode(
1718 self,
1719 encoder: &mut fidl::encoding::Encoder<'_, D>,
1720 offset: usize,
1721 _depth: fidl::encoding::Depth,
1722 ) -> fidl::Result<()> {
1723 encoder.debug_check_bounds::<Publication>(offset);
1724 fidl::encoding::Encode::<Publication, D>::encode(
1726 (
1727 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.port),
1728 <fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.text),
1729 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_priority),
1730 <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_weight),
1731 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.ptr_ttl),
1732 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.srv_ttl),
1733 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.txt_ttl),
1734 ),
1735 encoder, offset, _depth
1736 )
1737 }
1738 }
1739 unsafe impl<
1740 D: fidl::encoding::ResourceDialect,
1741 T0: fidl::encoding::Encode<u16, D>,
1742 T1: fidl::encoding::Encode<
1743 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1744 D,
1745 >,
1746 T2: fidl::encoding::Encode<u16, D>,
1747 T3: fidl::encoding::Encode<u16, D>,
1748 T4: fidl::encoding::Encode<i64, D>,
1749 T5: fidl::encoding::Encode<i64, D>,
1750 T6: fidl::encoding::Encode<i64, D>,
1751 > fidl::encoding::Encode<Publication, D> for (T0, T1, T2, T3, T4, T5, T6)
1752 {
1753 #[inline]
1754 unsafe fn encode(
1755 self,
1756 encoder: &mut fidl::encoding::Encoder<'_, D>,
1757 offset: usize,
1758 depth: fidl::encoding::Depth,
1759 ) -> fidl::Result<()> {
1760 encoder.debug_check_bounds::<Publication>(offset);
1761 unsafe {
1764 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1765 (ptr as *mut u64).write_unaligned(0);
1766 }
1767 unsafe {
1768 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
1769 (ptr as *mut u64).write_unaligned(0);
1770 }
1771 self.0.encode(encoder, offset + 0, depth)?;
1773 self.1.encode(encoder, offset + 8, depth)?;
1774 self.2.encode(encoder, offset + 24, depth)?;
1775 self.3.encode(encoder, offset + 26, depth)?;
1776 self.4.encode(encoder, offset + 32, depth)?;
1777 self.5.encode(encoder, offset + 40, depth)?;
1778 self.6.encode(encoder, offset + 48, depth)?;
1779 Ok(())
1780 }
1781 }
1782
1783 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Publication {
1784 #[inline(always)]
1785 fn new_empty() -> Self {
1786 Self {
1787 port: fidl::new_empty!(u16, D),
1788 text: fidl::new_empty!(
1789 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1790 D
1791 ),
1792 srv_priority: fidl::new_empty!(u16, D),
1793 srv_weight: fidl::new_empty!(u16, D),
1794 ptr_ttl: fidl::new_empty!(i64, D),
1795 srv_ttl: fidl::new_empty!(i64, D),
1796 txt_ttl: fidl::new_empty!(i64, D),
1797 }
1798 }
1799
1800 #[inline]
1801 unsafe fn decode(
1802 &mut self,
1803 decoder: &mut fidl::encoding::Decoder<'_, D>,
1804 offset: usize,
1805 _depth: fidl::encoding::Depth,
1806 ) -> fidl::Result<()> {
1807 decoder.debug_check_bounds::<Self>(offset);
1808 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1810 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1811 let mask = 0xffffffffffff0000u64;
1812 let maskedval = padval & mask;
1813 if maskedval != 0 {
1814 return Err(fidl::Error::NonZeroPadding {
1815 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1816 });
1817 }
1818 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
1819 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1820 let mask = 0xffffffff00000000u64;
1821 let maskedval = padval & mask;
1822 if maskedval != 0 {
1823 return Err(fidl::Error::NonZeroPadding {
1824 padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
1825 });
1826 }
1827 fidl::decode!(u16, D, &mut self.port, decoder, offset + 0, _depth)?;
1828 fidl::decode!(
1829 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
1830 D,
1831 &mut self.text,
1832 decoder,
1833 offset + 8,
1834 _depth
1835 )?;
1836 fidl::decode!(u16, D, &mut self.srv_priority, decoder, offset + 24, _depth)?;
1837 fidl::decode!(u16, D, &mut self.srv_weight, decoder, offset + 26, _depth)?;
1838 fidl::decode!(i64, D, &mut self.ptr_ttl, decoder, offset + 32, _depth)?;
1839 fidl::decode!(i64, D, &mut self.srv_ttl, decoder, offset + 40, _depth)?;
1840 fidl::decode!(i64, D, &mut self.txt_ttl, decoder, offset + 48, _depth)?;
1841 Ok(())
1842 }
1843 }
1844
1845 impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationRequest {
1846 type Borrowed<'a> = &'a Self;
1847 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1848 value
1849 }
1850 }
1851
1852 unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationRequest {
1853 type Owned = Self;
1854
1855 #[inline(always)]
1856 fn inline_align(_context: fidl::encoding::Context) -> usize {
1857 8
1858 }
1859
1860 #[inline(always)]
1861 fn inline_size(_context: fidl::encoding::Context) -> usize {
1862 40
1863 }
1864 }
1865
1866 unsafe impl<D: fidl::encoding::ResourceDialect>
1867 fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D>
1868 for &PublicationResponderOnPublicationRequest
1869 {
1870 #[inline]
1871 unsafe fn encode(
1872 self,
1873 encoder: &mut fidl::encoding::Encoder<'_, D>,
1874 offset: usize,
1875 _depth: fidl::encoding::Depth,
1876 ) -> fidl::Result<()> {
1877 encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1878 fidl::encoding::Encode::<PublicationResponderOnPublicationRequest, D>::encode(
1880 (
1881 <PublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
1882 <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
1883 <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
1884 ),
1885 encoder, offset, _depth
1886 )
1887 }
1888 }
1889 unsafe impl<
1890 D: fidl::encoding::ResourceDialect,
1891 T0: fidl::encoding::Encode<PublicationCause, D>,
1892 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
1893 T2: fidl::encoding::Encode<
1894 fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
1895 D,
1896 >,
1897 > fidl::encoding::Encode<PublicationResponderOnPublicationRequest, D> for (T0, T1, T2)
1898 {
1899 #[inline]
1900 unsafe fn encode(
1901 self,
1902 encoder: &mut fidl::encoding::Encoder<'_, D>,
1903 offset: usize,
1904 depth: fidl::encoding::Depth,
1905 ) -> fidl::Result<()> {
1906 encoder.debug_check_bounds::<PublicationResponderOnPublicationRequest>(offset);
1907 unsafe {
1910 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
1911 (ptr as *mut u64).write_unaligned(0);
1912 }
1913 self.0.encode(encoder, offset + 0, depth)?;
1915 self.1.encode(encoder, offset + 8, depth)?;
1916 self.2.encode(encoder, offset + 24, depth)?;
1917 Ok(())
1918 }
1919 }
1920
1921 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1922 for PublicationResponderOnPublicationRequest
1923 {
1924 #[inline(always)]
1925 fn new_empty() -> Self {
1926 Self {
1927 publication_cause: fidl::new_empty!(PublicationCause, D),
1928 subtype: fidl::new_empty!(
1929 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
1930 D
1931 ),
1932 source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
1933 }
1934 }
1935
1936 #[inline]
1937 unsafe fn decode(
1938 &mut self,
1939 decoder: &mut fidl::encoding::Decoder<'_, D>,
1940 offset: usize,
1941 _depth: fidl::encoding::Depth,
1942 ) -> fidl::Result<()> {
1943 decoder.debug_check_bounds::<Self>(offset);
1944 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
1946 let padval = unsafe { (ptr as *const u64).read_unaligned() };
1947 let mask = 0xffffffff00000000u64;
1948 let maskedval = padval & mask;
1949 if maskedval != 0 {
1950 return Err(fidl::Error::NonZeroPadding {
1951 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
1952 });
1953 }
1954 fidl::decode!(
1955 PublicationCause,
1956 D,
1957 &mut self.publication_cause,
1958 decoder,
1959 offset + 0,
1960 _depth
1961 )?;
1962 fidl::decode!(
1963 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
1964 D,
1965 &mut self.subtype,
1966 decoder,
1967 offset + 8,
1968 _depth
1969 )?;
1970 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
1971 Ok(())
1972 }
1973 }
1974
1975 impl fidl::encoding::ValueTypeMarker for PublicationResponderOnPublicationResponse {
1976 type Borrowed<'a> = &'a Self;
1977 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978 value
1979 }
1980 }
1981
1982 unsafe impl fidl::encoding::TypeMarker for PublicationResponderOnPublicationResponse {
1983 type Owned = Self;
1984
1985 #[inline(always)]
1986 fn inline_align(_context: fidl::encoding::Context) -> usize {
1987 8
1988 }
1989
1990 #[inline(always)]
1991 fn inline_size(_context: fidl::encoding::Context) -> usize {
1992 8
1993 }
1994 }
1995
1996 unsafe impl<D: fidl::encoding::ResourceDialect>
1997 fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D>
1998 for &PublicationResponderOnPublicationResponse
1999 {
2000 #[inline]
2001 unsafe fn encode(
2002 self,
2003 encoder: &mut fidl::encoding::Encoder<'_, D>,
2004 offset: usize,
2005 _depth: fidl::encoding::Depth,
2006 ) -> fidl::Result<()> {
2007 encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2008 fidl::encoding::Encode::<PublicationResponderOnPublicationResponse, D>::encode(
2010 (<fidl::encoding::Boxed<Publication> as fidl::encoding::ValueTypeMarker>::borrow(
2011 &self.publication,
2012 ),),
2013 encoder,
2014 offset,
2015 _depth,
2016 )
2017 }
2018 }
2019 unsafe impl<
2020 D: fidl::encoding::ResourceDialect,
2021 T0: fidl::encoding::Encode<fidl::encoding::Boxed<Publication>, D>,
2022 > fidl::encoding::Encode<PublicationResponderOnPublicationResponse, D> for (T0,)
2023 {
2024 #[inline]
2025 unsafe fn encode(
2026 self,
2027 encoder: &mut fidl::encoding::Encoder<'_, D>,
2028 offset: usize,
2029 depth: fidl::encoding::Depth,
2030 ) -> fidl::Result<()> {
2031 encoder.debug_check_bounds::<PublicationResponderOnPublicationResponse>(offset);
2032 self.0.encode(encoder, offset + 0, depth)?;
2036 Ok(())
2037 }
2038 }
2039
2040 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2041 for PublicationResponderOnPublicationResponse
2042 {
2043 #[inline(always)]
2044 fn new_empty() -> Self {
2045 Self { publication: fidl::new_empty!(fidl::encoding::Boxed<Publication>, D) }
2046 }
2047
2048 #[inline]
2049 unsafe fn decode(
2050 &mut self,
2051 decoder: &mut fidl::encoding::Decoder<'_, D>,
2052 offset: usize,
2053 _depth: fidl::encoding::Depth,
2054 ) -> fidl::Result<()> {
2055 decoder.debug_check_bounds::<Self>(offset);
2056 fidl::decode!(
2058 fidl::encoding::Boxed<Publication>,
2059 D,
2060 &mut self.publication,
2061 decoder,
2062 offset + 0,
2063 _depth
2064 )?;
2065 Ok(())
2066 }
2067 }
2068
2069 impl fidl::encoding::ValueTypeMarker for PublicationResponderSetSubtypesRequest {
2070 type Borrowed<'a> = &'a Self;
2071 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2072 value
2073 }
2074 }
2075
2076 unsafe impl fidl::encoding::TypeMarker for PublicationResponderSetSubtypesRequest {
2077 type Owned = Self;
2078
2079 #[inline(always)]
2080 fn inline_align(_context: fidl::encoding::Context) -> usize {
2081 8
2082 }
2083
2084 #[inline(always)]
2085 fn inline_size(_context: fidl::encoding::Context) -> usize {
2086 16
2087 }
2088 }
2089
2090 unsafe impl<D: fidl::encoding::ResourceDialect>
2091 fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D>
2092 for &PublicationResponderSetSubtypesRequest
2093 {
2094 #[inline]
2095 unsafe fn encode(
2096 self,
2097 encoder: &mut fidl::encoding::Encoder<'_, D>,
2098 offset: usize,
2099 _depth: fidl::encoding::Depth,
2100 ) -> fidl::Result<()> {
2101 encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2102 fidl::encoding::Encode::<PublicationResponderSetSubtypesRequest, D>::encode(
2104 (
2105 <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2106 ),
2107 encoder, offset, _depth
2108 )
2109 }
2110 }
2111 unsafe impl<
2112 D: fidl::encoding::ResourceDialect,
2113 T0: fidl::encoding::Encode<
2114 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2115 D,
2116 >,
2117 > fidl::encoding::Encode<PublicationResponderSetSubtypesRequest, D> for (T0,)
2118 {
2119 #[inline]
2120 unsafe fn encode(
2121 self,
2122 encoder: &mut fidl::encoding::Encoder<'_, D>,
2123 offset: usize,
2124 depth: fidl::encoding::Depth,
2125 ) -> fidl::Result<()> {
2126 encoder.debug_check_bounds::<PublicationResponderSetSubtypesRequest>(offset);
2127 self.0.encode(encoder, offset + 0, depth)?;
2131 Ok(())
2132 }
2133 }
2134
2135 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2136 for PublicationResponderSetSubtypesRequest
2137 {
2138 #[inline(always)]
2139 fn new_empty() -> Self {
2140 Self {
2141 subtypes: fidl::new_empty!(
2142 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2143 D
2144 ),
2145 }
2146 }
2147
2148 #[inline]
2149 unsafe fn decode(
2150 &mut self,
2151 decoder: &mut fidl::encoding::Decoder<'_, D>,
2152 offset: usize,
2153 _depth: fidl::encoding::Depth,
2154 ) -> fidl::Result<()> {
2155 decoder.debug_check_bounds::<Self>(offset);
2156 fidl::decode!(
2158 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2159 D,
2160 &mut self.subtypes,
2161 decoder,
2162 offset + 0,
2163 _depth
2164 )?;
2165 Ok(())
2166 }
2167 }
2168
2169 impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameRequest {
2170 type Borrowed<'a> = &'a Self;
2171 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2172 value
2173 }
2174 }
2175
2176 unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameRequest {
2177 type Owned = Self;
2178
2179 #[inline(always)]
2180 fn inline_align(_context: fidl::encoding::Context) -> usize {
2181 8
2182 }
2183
2184 #[inline(always)]
2185 fn inline_size(_context: fidl::encoding::Context) -> usize {
2186 24
2187 }
2188 }
2189
2190 unsafe impl<D: fidl::encoding::ResourceDialect>
2191 fidl::encoding::Encode<ResolverResolveHostNameRequest, D>
2192 for &ResolverResolveHostNameRequest
2193 {
2194 #[inline]
2195 unsafe fn encode(
2196 self,
2197 encoder: &mut fidl::encoding::Encoder<'_, D>,
2198 offset: usize,
2199 _depth: fidl::encoding::Depth,
2200 ) -> fidl::Result<()> {
2201 encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2202 fidl::encoding::Encode::<ResolverResolveHostNameRequest, D>::encode(
2204 (
2205 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
2206 &self.host,
2207 ),
2208 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2209 ),
2210 encoder,
2211 offset,
2212 _depth,
2213 )
2214 }
2215 }
2216 unsafe impl<
2217 D: fidl::encoding::ResourceDialect,
2218 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
2219 T1: fidl::encoding::Encode<i64, D>,
2220 > fidl::encoding::Encode<ResolverResolveHostNameRequest, D> for (T0, T1)
2221 {
2222 #[inline]
2223 unsafe fn encode(
2224 self,
2225 encoder: &mut fidl::encoding::Encoder<'_, D>,
2226 offset: usize,
2227 depth: fidl::encoding::Depth,
2228 ) -> fidl::Result<()> {
2229 encoder.debug_check_bounds::<ResolverResolveHostNameRequest>(offset);
2230 self.0.encode(encoder, offset + 0, depth)?;
2234 self.1.encode(encoder, offset + 16, depth)?;
2235 Ok(())
2236 }
2237 }
2238
2239 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2240 for ResolverResolveHostNameRequest
2241 {
2242 #[inline(always)]
2243 fn new_empty() -> Self {
2244 Self {
2245 host: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
2246 timeout: fidl::new_empty!(i64, D),
2247 }
2248 }
2249
2250 #[inline]
2251 unsafe fn decode(
2252 &mut self,
2253 decoder: &mut fidl::encoding::Decoder<'_, D>,
2254 offset: usize,
2255 _depth: fidl::encoding::Depth,
2256 ) -> fidl::Result<()> {
2257 decoder.debug_check_bounds::<Self>(offset);
2258 fidl::decode!(
2260 fidl::encoding::BoundedString<255>,
2261 D,
2262 &mut self.host,
2263 decoder,
2264 offset + 0,
2265 _depth
2266 )?;
2267 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 16, _depth)?;
2268 Ok(())
2269 }
2270 }
2271
2272 impl fidl::encoding::ValueTypeMarker for ResolverResolveHostNameResponse {
2273 type Borrowed<'a> = &'a Self;
2274 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2275 value
2276 }
2277 }
2278
2279 unsafe impl fidl::encoding::TypeMarker for ResolverResolveHostNameResponse {
2280 type Owned = Self;
2281
2282 #[inline(always)]
2283 fn inline_align(_context: fidl::encoding::Context) -> usize {
2284 8
2285 }
2286
2287 #[inline(always)]
2288 fn inline_size(_context: fidl::encoding::Context) -> usize {
2289 16
2290 }
2291 }
2292
2293 unsafe impl<D: fidl::encoding::ResourceDialect>
2294 fidl::encoding::Encode<ResolverResolveHostNameResponse, D>
2295 for &ResolverResolveHostNameResponse
2296 {
2297 #[inline]
2298 unsafe fn encode(
2299 self,
2300 encoder: &mut fidl::encoding::Encoder<'_, D>,
2301 offset: usize,
2302 _depth: fidl::encoding::Depth,
2303 ) -> fidl::Result<()> {
2304 encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2305 fidl::encoding::Encode::<ResolverResolveHostNameResponse, D>::encode(
2307 (
2308 <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v4_address),
2309 <fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address> as fidl::encoding::ValueTypeMarker>::borrow(&self.v6_address),
2310 ),
2311 encoder, offset, _depth
2312 )
2313 }
2314 }
2315 unsafe impl<
2316 D: fidl::encoding::ResourceDialect,
2317 T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>, D>,
2318 T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>, D>,
2319 > fidl::encoding::Encode<ResolverResolveHostNameResponse, D> for (T0, T1)
2320 {
2321 #[inline]
2322 unsafe fn encode(
2323 self,
2324 encoder: &mut fidl::encoding::Encoder<'_, D>,
2325 offset: usize,
2326 depth: fidl::encoding::Depth,
2327 ) -> fidl::Result<()> {
2328 encoder.debug_check_bounds::<ResolverResolveHostNameResponse>(offset);
2329 self.0.encode(encoder, offset + 0, depth)?;
2333 self.1.encode(encoder, offset + 8, depth)?;
2334 Ok(())
2335 }
2336 }
2337
2338 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2339 for ResolverResolveHostNameResponse
2340 {
2341 #[inline(always)]
2342 fn new_empty() -> Self {
2343 Self {
2344 v4_address: fidl::new_empty!(
2345 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2346 D
2347 ),
2348 v6_address: fidl::new_empty!(
2349 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2350 D
2351 ),
2352 }
2353 }
2354
2355 #[inline]
2356 unsafe fn decode(
2357 &mut self,
2358 decoder: &mut fidl::encoding::Decoder<'_, D>,
2359 offset: usize,
2360 _depth: fidl::encoding::Depth,
2361 ) -> fidl::Result<()> {
2362 decoder.debug_check_bounds::<Self>(offset);
2363 fidl::decode!(
2365 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv4Address>,
2366 D,
2367 &mut self.v4_address,
2368 decoder,
2369 offset + 0,
2370 _depth
2371 )?;
2372 fidl::decode!(
2373 fidl::encoding::Boxed<fidl_fuchsia_net__common::Ipv6Address>,
2374 D,
2375 &mut self.v6_address,
2376 decoder,
2377 offset + 8,
2378 _depth
2379 )?;
2380 Ok(())
2381 }
2382 }
2383
2384 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2385 type Borrowed<'a> = &'a Self;
2386 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2387 value
2388 }
2389 }
2390
2391 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderOnPublicationRequest {
2392 type Owned = Self;
2393
2394 #[inline(always)]
2395 fn inline_align(_context: fidl::encoding::Context) -> usize {
2396 8
2397 }
2398
2399 #[inline(always)]
2400 fn inline_size(_context: fidl::encoding::Context) -> usize {
2401 40
2402 }
2403 }
2404
2405 unsafe impl<D: fidl::encoding::ResourceDialect>
2406 fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2407 for &ServiceInstancePublicationResponderOnPublicationRequest
2408 {
2409 #[inline]
2410 unsafe fn encode(
2411 self,
2412 encoder: &mut fidl::encoding::Encoder<'_, D>,
2413 offset: usize,
2414 _depth: fidl::encoding::Depth,
2415 ) -> fidl::Result<()> {
2416 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2417 offset,
2418 );
2419 fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationRequest, D>::encode(
2421 (
2422 <ServiceInstancePublicationCause as fidl::encoding::ValueTypeMarker>::borrow(&self.publication_cause),
2423 <fidl::encoding::Optional<fidl::encoding::BoundedString<63>> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtype),
2424 <fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow(&self.source_addresses),
2425 ),
2426 encoder, offset, _depth
2427 )
2428 }
2429 }
2430 unsafe impl<
2431 D: fidl::encoding::ResourceDialect,
2432 T0: fidl::encoding::Encode<ServiceInstancePublicationCause, D>,
2433 T1: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<63>>, D>,
2434 T2: fidl::encoding::Encode<
2435 fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>,
2436 D,
2437 >,
2438 > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationRequest, D>
2439 for (T0, T1, T2)
2440 {
2441 #[inline]
2442 unsafe fn encode(
2443 self,
2444 encoder: &mut fidl::encoding::Encoder<'_, D>,
2445 offset: usize,
2446 depth: fidl::encoding::Depth,
2447 ) -> fidl::Result<()> {
2448 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationRequest>(
2449 offset,
2450 );
2451 unsafe {
2454 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
2455 (ptr as *mut u64).write_unaligned(0);
2456 }
2457 self.0.encode(encoder, offset + 0, depth)?;
2459 self.1.encode(encoder, offset + 8, depth)?;
2460 self.2.encode(encoder, offset + 24, depth)?;
2461 Ok(())
2462 }
2463 }
2464
2465 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2466 for ServiceInstancePublicationResponderOnPublicationRequest
2467 {
2468 #[inline(always)]
2469 fn new_empty() -> Self {
2470 Self {
2471 publication_cause: fidl::new_empty!(ServiceInstancePublicationCause, D),
2472 subtype: fidl::new_empty!(
2473 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2474 D
2475 ),
2476 source_addresses: fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D),
2477 }
2478 }
2479
2480 #[inline]
2481 unsafe fn decode(
2482 &mut self,
2483 decoder: &mut fidl::encoding::Decoder<'_, D>,
2484 offset: usize,
2485 _depth: fidl::encoding::Depth,
2486 ) -> fidl::Result<()> {
2487 decoder.debug_check_bounds::<Self>(offset);
2488 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
2490 let padval = unsafe { (ptr as *const u64).read_unaligned() };
2491 let mask = 0xffffffff00000000u64;
2492 let maskedval = padval & mask;
2493 if maskedval != 0 {
2494 return Err(fidl::Error::NonZeroPadding {
2495 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
2496 });
2497 }
2498 fidl::decode!(
2499 ServiceInstancePublicationCause,
2500 D,
2501 &mut self.publication_cause,
2502 decoder,
2503 offset + 0,
2504 _depth
2505 )?;
2506 fidl::decode!(
2507 fidl::encoding::Optional<fidl::encoding::BoundedString<63>>,
2508 D,
2509 &mut self.subtype,
2510 decoder,
2511 offset + 8,
2512 _depth
2513 )?;
2514 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::IpAddress, 64>, D, &mut self.source_addresses, decoder, offset + 24, _depth)?;
2515 Ok(())
2516 }
2517 }
2518
2519 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2520 type Borrowed<'a> = &'a Self;
2521 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2522 value
2523 }
2524 }
2525
2526 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationResponderSetSubtypesRequest {
2527 type Owned = Self;
2528
2529 #[inline(always)]
2530 fn inline_align(_context: fidl::encoding::Context) -> usize {
2531 8
2532 }
2533
2534 #[inline(always)]
2535 fn inline_size(_context: fidl::encoding::Context) -> usize {
2536 16
2537 }
2538 }
2539
2540 unsafe impl<D: fidl::encoding::ResourceDialect>
2541 fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2542 for &ServiceInstancePublicationResponderSetSubtypesRequest
2543 {
2544 #[inline]
2545 unsafe fn encode(
2546 self,
2547 encoder: &mut fidl::encoding::Encoder<'_, D>,
2548 offset: usize,
2549 _depth: fidl::encoding::Depth,
2550 ) -> fidl::Result<()> {
2551 encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2552 offset,
2553 );
2554 fidl::encoding::Encode::<ServiceInstancePublicationResponderSetSubtypesRequest, D>::encode(
2556 (
2557 <fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.subtypes),
2558 ),
2559 encoder, offset, _depth
2560 )
2561 }
2562 }
2563 unsafe impl<
2564 D: fidl::encoding::ResourceDialect,
2565 T0: fidl::encoding::Encode<
2566 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2567 D,
2568 >,
2569 > fidl::encoding::Encode<ServiceInstancePublicationResponderSetSubtypesRequest, D>
2570 for (T0,)
2571 {
2572 #[inline]
2573 unsafe fn encode(
2574 self,
2575 encoder: &mut fidl::encoding::Encoder<'_, D>,
2576 offset: usize,
2577 depth: fidl::encoding::Depth,
2578 ) -> fidl::Result<()> {
2579 encoder.debug_check_bounds::<ServiceInstancePublicationResponderSetSubtypesRequest>(
2580 offset,
2581 );
2582 self.0.encode(encoder, offset + 0, depth)?;
2586 Ok(())
2587 }
2588 }
2589
2590 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2591 for ServiceInstancePublicationResponderSetSubtypesRequest
2592 {
2593 #[inline(always)]
2594 fn new_empty() -> Self {
2595 Self {
2596 subtypes: fidl::new_empty!(
2597 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2598 D
2599 ),
2600 }
2601 }
2602
2603 #[inline]
2604 unsafe fn decode(
2605 &mut self,
2606 decoder: &mut fidl::encoding::Decoder<'_, D>,
2607 offset: usize,
2608 _depth: fidl::encoding::Depth,
2609 ) -> fidl::Result<()> {
2610 decoder.debug_check_bounds::<Self>(offset);
2611 fidl::decode!(
2613 fidl::encoding::Vector<fidl::encoding::BoundedString<63>, 256>,
2614 D,
2615 &mut self.subtypes,
2616 decoder,
2617 offset + 0,
2618 _depth
2619 )?;
2620 Ok(())
2621 }
2622 }
2623
2624 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationResponderOnPublicationResponse {
2625 type Borrowed<'a> = &'a Self;
2626 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2627 value
2628 }
2629 }
2630
2631 unsafe impl fidl::encoding::TypeMarker
2632 for ServiceInstancePublicationResponderOnPublicationResponse
2633 {
2634 type Owned = Self;
2635
2636 #[inline(always)]
2637 fn inline_align(_context: fidl::encoding::Context) -> usize {
2638 8
2639 }
2640
2641 #[inline(always)]
2642 fn inline_size(_context: fidl::encoding::Context) -> usize {
2643 16
2644 }
2645 }
2646
2647 unsafe impl<D: fidl::encoding::ResourceDialect>
2648 fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2649 for &ServiceInstancePublicationResponderOnPublicationResponse
2650 {
2651 #[inline]
2652 unsafe fn encode(
2653 self,
2654 encoder: &mut fidl::encoding::Encoder<'_, D>,
2655 offset: usize,
2656 _depth: fidl::encoding::Depth,
2657 ) -> fidl::Result<()> {
2658 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2659 offset,
2660 );
2661 fidl::encoding::Encode::<ServiceInstancePublicationResponderOnPublicationResponse, D>::encode(
2663 (
2664 <ServiceInstancePublication as fidl::encoding::ValueTypeMarker>::borrow(&self.publication),
2665 ),
2666 encoder, offset, _depth
2667 )
2668 }
2669 }
2670 unsafe impl<
2671 D: fidl::encoding::ResourceDialect,
2672 T0: fidl::encoding::Encode<ServiceInstancePublication, D>,
2673 > fidl::encoding::Encode<ServiceInstancePublicationResponderOnPublicationResponse, D>
2674 for (T0,)
2675 {
2676 #[inline]
2677 unsafe fn encode(
2678 self,
2679 encoder: &mut fidl::encoding::Encoder<'_, D>,
2680 offset: usize,
2681 depth: fidl::encoding::Depth,
2682 ) -> fidl::Result<()> {
2683 encoder.debug_check_bounds::<ServiceInstancePublicationResponderOnPublicationResponse>(
2684 offset,
2685 );
2686 self.0.encode(encoder, offset + 0, depth)?;
2690 Ok(())
2691 }
2692 }
2693
2694 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2695 for ServiceInstancePublicationResponderOnPublicationResponse
2696 {
2697 #[inline(always)]
2698 fn new_empty() -> Self {
2699 Self { publication: fidl::new_empty!(ServiceInstancePublication, D) }
2700 }
2701
2702 #[inline]
2703 unsafe fn decode(
2704 &mut self,
2705 decoder: &mut fidl::encoding::Decoder<'_, D>,
2706 offset: usize,
2707 _depth: fidl::encoding::Depth,
2708 ) -> fidl::Result<()> {
2709 decoder.debug_check_bounds::<Self>(offset);
2710 fidl::decode!(
2712 ServiceInstancePublication,
2713 D,
2714 &mut self.publication,
2715 decoder,
2716 offset + 0,
2717 _depth
2718 )?;
2719 Ok(())
2720 }
2721 }
2722
2723 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2724 type Borrowed<'a> = &'a Self;
2725 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2726 value
2727 }
2728 }
2729
2730 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceRequest {
2731 type Owned = Self;
2732
2733 #[inline(always)]
2734 fn inline_align(_context: fidl::encoding::Context) -> usize {
2735 8
2736 }
2737
2738 #[inline(always)]
2739 fn inline_size(_context: fidl::encoding::Context) -> usize {
2740 56
2741 }
2742 }
2743
2744 unsafe impl<D: fidl::encoding::ResourceDialect>
2745 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2746 for &ServiceInstanceResolverResolveServiceInstanceRequest
2747 {
2748 #[inline]
2749 unsafe fn encode(
2750 self,
2751 encoder: &mut fidl::encoding::Encoder<'_, D>,
2752 offset: usize,
2753 _depth: fidl::encoding::Depth,
2754 ) -> fidl::Result<()> {
2755 encoder
2756 .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2757 fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceRequest, D>::encode(
2759 (
2760 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(&self.service),
2761 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2762 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timeout),
2763 <ServiceInstanceResolutionOptions as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2764 ),
2765 encoder, offset, _depth
2766 )
2767 }
2768 }
2769 unsafe impl<
2770 D: fidl::encoding::ResourceDialect,
2771 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
2772 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
2773 T2: fidl::encoding::Encode<i64, D>,
2774 T3: fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>,
2775 > fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceRequest, D>
2776 for (T0, T1, T2, T3)
2777 {
2778 #[inline]
2779 unsafe fn encode(
2780 self,
2781 encoder: &mut fidl::encoding::Encoder<'_, D>,
2782 offset: usize,
2783 depth: fidl::encoding::Depth,
2784 ) -> fidl::Result<()> {
2785 encoder
2786 .debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceRequest>(offset);
2787 self.0.encode(encoder, offset + 0, depth)?;
2791 self.1.encode(encoder, offset + 16, depth)?;
2792 self.2.encode(encoder, offset + 32, depth)?;
2793 self.3.encode(encoder, offset + 40, depth)?;
2794 Ok(())
2795 }
2796 }
2797
2798 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2799 for ServiceInstanceResolverResolveServiceInstanceRequest
2800 {
2801 #[inline(always)]
2802 fn new_empty() -> Self {
2803 Self {
2804 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
2805 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
2806 timeout: fidl::new_empty!(i64, D),
2807 options: fidl::new_empty!(ServiceInstanceResolutionOptions, D),
2808 }
2809 }
2810
2811 #[inline]
2812 unsafe fn decode(
2813 &mut self,
2814 decoder: &mut fidl::encoding::Decoder<'_, D>,
2815 offset: usize,
2816 _depth: fidl::encoding::Depth,
2817 ) -> fidl::Result<()> {
2818 decoder.debug_check_bounds::<Self>(offset);
2819 fidl::decode!(
2821 fidl::encoding::BoundedString<22>,
2822 D,
2823 &mut self.service,
2824 decoder,
2825 offset + 0,
2826 _depth
2827 )?;
2828 fidl::decode!(
2829 fidl::encoding::BoundedString<63>,
2830 D,
2831 &mut self.instance,
2832 decoder,
2833 offset + 16,
2834 _depth
2835 )?;
2836 fidl::decode!(i64, D, &mut self.timeout, decoder, offset + 32, _depth)?;
2837 fidl::decode!(
2838 ServiceInstanceResolutionOptions,
2839 D,
2840 &mut self.options,
2841 decoder,
2842 offset + 40,
2843 _depth
2844 )?;
2845 Ok(())
2846 }
2847 }
2848
2849 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2850 type Borrowed<'a> = &'a Self;
2851 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2852 value
2853 }
2854 }
2855
2856 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolverResolveServiceInstanceResponse {
2857 type Owned = Self;
2858
2859 #[inline(always)]
2860 fn inline_align(_context: fidl::encoding::Context) -> usize {
2861 8
2862 }
2863
2864 #[inline(always)]
2865 fn inline_size(_context: fidl::encoding::Context) -> usize {
2866 16
2867 }
2868 }
2869
2870 unsafe impl<D: fidl::encoding::ResourceDialect>
2871 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D>
2872 for &ServiceInstanceResolverResolveServiceInstanceResponse
2873 {
2874 #[inline]
2875 unsafe fn encode(
2876 self,
2877 encoder: &mut fidl::encoding::Encoder<'_, D>,
2878 offset: usize,
2879 _depth: fidl::encoding::Depth,
2880 ) -> fidl::Result<()> {
2881 encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2882 offset,
2883 );
2884 fidl::encoding::Encode::<ServiceInstanceResolverResolveServiceInstanceResponse, D>::encode(
2886 (
2887 <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
2888 ),
2889 encoder, offset, _depth
2890 )
2891 }
2892 }
2893 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
2894 fidl::encoding::Encode<ServiceInstanceResolverResolveServiceInstanceResponse, D> for (T0,)
2895 {
2896 #[inline]
2897 unsafe fn encode(
2898 self,
2899 encoder: &mut fidl::encoding::Encoder<'_, D>,
2900 offset: usize,
2901 depth: fidl::encoding::Depth,
2902 ) -> fidl::Result<()> {
2903 encoder.debug_check_bounds::<ServiceInstanceResolverResolveServiceInstanceResponse>(
2904 offset,
2905 );
2906 self.0.encode(encoder, offset + 0, depth)?;
2910 Ok(())
2911 }
2912 }
2913
2914 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2915 for ServiceInstanceResolverResolveServiceInstanceResponse
2916 {
2917 #[inline(always)]
2918 fn new_empty() -> Self {
2919 Self { instance: fidl::new_empty!(ServiceInstance, D) }
2920 }
2921
2922 #[inline]
2923 unsafe fn decode(
2924 &mut self,
2925 decoder: &mut fidl::encoding::Decoder<'_, D>,
2926 offset: usize,
2927 _depth: fidl::encoding::Depth,
2928 ) -> fidl::Result<()> {
2929 decoder.debug_check_bounds::<Self>(offset);
2930 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
2932 Ok(())
2933 }
2934 }
2935
2936 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceChangedRequest {
2937 type Borrowed<'a> = &'a Self;
2938 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2939 value
2940 }
2941 }
2942
2943 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceChangedRequest {
2944 type Owned = Self;
2945
2946 #[inline(always)]
2947 fn inline_align(_context: fidl::encoding::Context) -> usize {
2948 8
2949 }
2950
2951 #[inline(always)]
2952 fn inline_size(_context: fidl::encoding::Context) -> usize {
2953 16
2954 }
2955 }
2956
2957 unsafe impl<D: fidl::encoding::ResourceDialect>
2958 fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D>
2959 for &ServiceSubscriberOnInstanceChangedRequest
2960 {
2961 #[inline]
2962 unsafe fn encode(
2963 self,
2964 encoder: &mut fidl::encoding::Encoder<'_, D>,
2965 offset: usize,
2966 _depth: fidl::encoding::Depth,
2967 ) -> fidl::Result<()> {
2968 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
2969 fidl::encoding::Encode::<ServiceSubscriberOnInstanceChangedRequest, D>::encode(
2971 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
2972 encoder,
2973 offset,
2974 _depth,
2975 )
2976 }
2977 }
2978 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
2979 fidl::encoding::Encode<ServiceSubscriberOnInstanceChangedRequest, D> for (T0,)
2980 {
2981 #[inline]
2982 unsafe fn encode(
2983 self,
2984 encoder: &mut fidl::encoding::Encoder<'_, D>,
2985 offset: usize,
2986 depth: fidl::encoding::Depth,
2987 ) -> fidl::Result<()> {
2988 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceChangedRequest>(offset);
2989 self.0.encode(encoder, offset + 0, depth)?;
2993 Ok(())
2994 }
2995 }
2996
2997 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2998 for ServiceSubscriberOnInstanceChangedRequest
2999 {
3000 #[inline(always)]
3001 fn new_empty() -> Self {
3002 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3003 }
3004
3005 #[inline]
3006 unsafe fn decode(
3007 &mut self,
3008 decoder: &mut fidl::encoding::Decoder<'_, D>,
3009 offset: usize,
3010 _depth: fidl::encoding::Depth,
3011 ) -> fidl::Result<()> {
3012 decoder.debug_check_bounds::<Self>(offset);
3013 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3015 Ok(())
3016 }
3017 }
3018
3019 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3020 type Borrowed<'a> = &'a Self;
3021 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3022 value
3023 }
3024 }
3025
3026 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceDiscoveredRequest {
3027 type Owned = Self;
3028
3029 #[inline(always)]
3030 fn inline_align(_context: fidl::encoding::Context) -> usize {
3031 8
3032 }
3033
3034 #[inline(always)]
3035 fn inline_size(_context: fidl::encoding::Context) -> usize {
3036 16
3037 }
3038 }
3039
3040 unsafe impl<D: fidl::encoding::ResourceDialect>
3041 fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D>
3042 for &ServiceSubscriberOnInstanceDiscoveredRequest
3043 {
3044 #[inline]
3045 unsafe fn encode(
3046 self,
3047 encoder: &mut fidl::encoding::Encoder<'_, D>,
3048 offset: usize,
3049 _depth: fidl::encoding::Depth,
3050 ) -> fidl::Result<()> {
3051 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3052 fidl::encoding::Encode::<ServiceSubscriberOnInstanceDiscoveredRequest, D>::encode(
3054 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3055 encoder,
3056 offset,
3057 _depth,
3058 )
3059 }
3060 }
3061 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3062 fidl::encoding::Encode<ServiceSubscriberOnInstanceDiscoveredRequest, D> for (T0,)
3063 {
3064 #[inline]
3065 unsafe fn encode(
3066 self,
3067 encoder: &mut fidl::encoding::Encoder<'_, D>,
3068 offset: usize,
3069 depth: fidl::encoding::Depth,
3070 ) -> fidl::Result<()> {
3071 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceDiscoveredRequest>(offset);
3072 self.0.encode(encoder, offset + 0, depth)?;
3076 Ok(())
3077 }
3078 }
3079
3080 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3081 for ServiceSubscriberOnInstanceDiscoveredRequest
3082 {
3083 #[inline(always)]
3084 fn new_empty() -> Self {
3085 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3086 }
3087
3088 #[inline]
3089 unsafe fn decode(
3090 &mut self,
3091 decoder: &mut fidl::encoding::Decoder<'_, D>,
3092 offset: usize,
3093 _depth: fidl::encoding::Depth,
3094 ) -> fidl::Result<()> {
3095 decoder.debug_check_bounds::<Self>(offset);
3096 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3098 Ok(())
3099 }
3100 }
3101
3102 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnInstanceLostRequest {
3103 type Borrowed<'a> = &'a Self;
3104 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3105 value
3106 }
3107 }
3108
3109 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnInstanceLostRequest {
3110 type Owned = Self;
3111
3112 #[inline(always)]
3113 fn inline_align(_context: fidl::encoding::Context) -> usize {
3114 8
3115 }
3116
3117 #[inline(always)]
3118 fn inline_size(_context: fidl::encoding::Context) -> usize {
3119 32
3120 }
3121 }
3122
3123 unsafe impl<D: fidl::encoding::ResourceDialect>
3124 fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D>
3125 for &ServiceSubscriberOnInstanceLostRequest
3126 {
3127 #[inline]
3128 unsafe fn encode(
3129 self,
3130 encoder: &mut fidl::encoding::Encoder<'_, D>,
3131 offset: usize,
3132 _depth: fidl::encoding::Depth,
3133 ) -> fidl::Result<()> {
3134 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3135 fidl::encoding::Encode::<ServiceSubscriberOnInstanceLostRequest, D>::encode(
3137 (
3138 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3139 &self.service,
3140 ),
3141 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3142 &self.instance,
3143 ),
3144 ),
3145 encoder,
3146 offset,
3147 _depth,
3148 )
3149 }
3150 }
3151 unsafe impl<
3152 D: fidl::encoding::ResourceDialect,
3153 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3154 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3155 > fidl::encoding::Encode<ServiceSubscriberOnInstanceLostRequest, D> for (T0, T1)
3156 {
3157 #[inline]
3158 unsafe fn encode(
3159 self,
3160 encoder: &mut fidl::encoding::Encoder<'_, D>,
3161 offset: usize,
3162 depth: fidl::encoding::Depth,
3163 ) -> fidl::Result<()> {
3164 encoder.debug_check_bounds::<ServiceSubscriberOnInstanceLostRequest>(offset);
3165 self.0.encode(encoder, offset + 0, depth)?;
3169 self.1.encode(encoder, offset + 16, depth)?;
3170 Ok(())
3171 }
3172 }
3173
3174 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3175 for ServiceSubscriberOnInstanceLostRequest
3176 {
3177 #[inline(always)]
3178 fn new_empty() -> Self {
3179 Self {
3180 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3181 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3182 }
3183 }
3184
3185 #[inline]
3186 unsafe fn decode(
3187 &mut self,
3188 decoder: &mut fidl::encoding::Decoder<'_, D>,
3189 offset: usize,
3190 _depth: fidl::encoding::Depth,
3191 ) -> fidl::Result<()> {
3192 decoder.debug_check_bounds::<Self>(offset);
3193 fidl::decode!(
3195 fidl::encoding::BoundedString<22>,
3196 D,
3197 &mut self.service,
3198 decoder,
3199 offset + 0,
3200 _depth
3201 )?;
3202 fidl::decode!(
3203 fidl::encoding::BoundedString<63>,
3204 D,
3205 &mut self.instance,
3206 decoder,
3207 offset + 16,
3208 _depth
3209 )?;
3210 Ok(())
3211 }
3212 }
3213
3214 impl fidl::encoding::ValueTypeMarker for ServiceSubscriberOnQueryRequest {
3215 type Borrowed<'a> = &'a Self;
3216 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3217 value
3218 }
3219 }
3220
3221 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriberOnQueryRequest {
3222 type Owned = Self;
3223
3224 #[inline(always)]
3225 fn inline_align(_context: fidl::encoding::Context) -> usize {
3226 4
3227 }
3228
3229 #[inline(always)]
3230 fn inline_size(_context: fidl::encoding::Context) -> usize {
3231 4
3232 }
3233 }
3234
3235 unsafe impl<D: fidl::encoding::ResourceDialect>
3236 fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D>
3237 for &ServiceSubscriberOnQueryRequest
3238 {
3239 #[inline]
3240 unsafe fn encode(
3241 self,
3242 encoder: &mut fidl::encoding::Encoder<'_, D>,
3243 offset: usize,
3244 _depth: fidl::encoding::Depth,
3245 ) -> fidl::Result<()> {
3246 encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3247 fidl::encoding::Encode::<ServiceSubscriberOnQueryRequest, D>::encode(
3249 (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3250 encoder,
3251 offset,
3252 _depth,
3253 )
3254 }
3255 }
3256 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3257 fidl::encoding::Encode<ServiceSubscriberOnQueryRequest, D> for (T0,)
3258 {
3259 #[inline]
3260 unsafe fn encode(
3261 self,
3262 encoder: &mut fidl::encoding::Encoder<'_, D>,
3263 offset: usize,
3264 depth: fidl::encoding::Depth,
3265 ) -> fidl::Result<()> {
3266 encoder.debug_check_bounds::<ServiceSubscriberOnQueryRequest>(offset);
3267 self.0.encode(encoder, offset + 0, depth)?;
3271 Ok(())
3272 }
3273 }
3274
3275 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3276 for ServiceSubscriberOnQueryRequest
3277 {
3278 #[inline(always)]
3279 fn new_empty() -> Self {
3280 Self { resource_type: fidl::new_empty!(ResourceType, D) }
3281 }
3282
3283 #[inline]
3284 unsafe fn decode(
3285 &mut self,
3286 decoder: &mut fidl::encoding::Decoder<'_, D>,
3287 offset: usize,
3288 _depth: fidl::encoding::Depth,
3289 ) -> fidl::Result<()> {
3290 decoder.debug_check_bounds::<Self>(offset);
3291 fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3293 Ok(())
3294 }
3295 }
3296
3297 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3298 type Borrowed<'a> = &'a Self;
3299 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3300 value
3301 }
3302 }
3303
3304 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceChangedRequest {
3305 type Owned = Self;
3306
3307 #[inline(always)]
3308 fn inline_align(_context: fidl::encoding::Context) -> usize {
3309 8
3310 }
3311
3312 #[inline(always)]
3313 fn inline_size(_context: fidl::encoding::Context) -> usize {
3314 16
3315 }
3316 }
3317
3318 unsafe impl<D: fidl::encoding::ResourceDialect>
3319 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D>
3320 for &ServiceSubscriptionListenerOnInstanceChangedRequest
3321 {
3322 #[inline]
3323 unsafe fn encode(
3324 self,
3325 encoder: &mut fidl::encoding::Encoder<'_, D>,
3326 offset: usize,
3327 _depth: fidl::encoding::Depth,
3328 ) -> fidl::Result<()> {
3329 encoder
3330 .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3331 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceChangedRequest, D>::encode(
3333 (<ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),),
3334 encoder,
3335 offset,
3336 _depth,
3337 )
3338 }
3339 }
3340 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3341 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceChangedRequest, D> for (T0,)
3342 {
3343 #[inline]
3344 unsafe fn encode(
3345 self,
3346 encoder: &mut fidl::encoding::Encoder<'_, D>,
3347 offset: usize,
3348 depth: fidl::encoding::Depth,
3349 ) -> fidl::Result<()> {
3350 encoder
3351 .debug_check_bounds::<ServiceSubscriptionListenerOnInstanceChangedRequest>(offset);
3352 self.0.encode(encoder, offset + 0, depth)?;
3356 Ok(())
3357 }
3358 }
3359
3360 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3361 for ServiceSubscriptionListenerOnInstanceChangedRequest
3362 {
3363 #[inline(always)]
3364 fn new_empty() -> Self {
3365 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3366 }
3367
3368 #[inline]
3369 unsafe fn decode(
3370 &mut self,
3371 decoder: &mut fidl::encoding::Decoder<'_, D>,
3372 offset: usize,
3373 _depth: fidl::encoding::Depth,
3374 ) -> fidl::Result<()> {
3375 decoder.debug_check_bounds::<Self>(offset);
3376 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3378 Ok(())
3379 }
3380 }
3381
3382 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3383 type Borrowed<'a> = &'a Self;
3384 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3385 value
3386 }
3387 }
3388
3389 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceDiscoveredRequest {
3390 type Owned = Self;
3391
3392 #[inline(always)]
3393 fn inline_align(_context: fidl::encoding::Context) -> usize {
3394 8
3395 }
3396
3397 #[inline(always)]
3398 fn inline_size(_context: fidl::encoding::Context) -> usize {
3399 16
3400 }
3401 }
3402
3403 unsafe impl<D: fidl::encoding::ResourceDialect>
3404 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>
3405 for &ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3406 {
3407 #[inline]
3408 unsafe fn encode(
3409 self,
3410 encoder: &mut fidl::encoding::Encoder<'_, D>,
3411 offset: usize,
3412 _depth: fidl::encoding::Depth,
3413 ) -> fidl::Result<()> {
3414 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3415 offset,
3416 );
3417 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D>::encode(
3419 (
3420 <ServiceInstance as fidl::encoding::ValueTypeMarker>::borrow(&self.instance),
3421 ),
3422 encoder, offset, _depth
3423 )
3424 }
3425 }
3426 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ServiceInstance, D>>
3427 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceDiscoveredRequest, D> for (T0,)
3428 {
3429 #[inline]
3430 unsafe fn encode(
3431 self,
3432 encoder: &mut fidl::encoding::Encoder<'_, D>,
3433 offset: usize,
3434 depth: fidl::encoding::Depth,
3435 ) -> fidl::Result<()> {
3436 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceDiscoveredRequest>(
3437 offset,
3438 );
3439 self.0.encode(encoder, offset + 0, depth)?;
3443 Ok(())
3444 }
3445 }
3446
3447 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3448 for ServiceSubscriptionListenerOnInstanceDiscoveredRequest
3449 {
3450 #[inline(always)]
3451 fn new_empty() -> Self {
3452 Self { instance: fidl::new_empty!(ServiceInstance, D) }
3453 }
3454
3455 #[inline]
3456 unsafe fn decode(
3457 &mut self,
3458 decoder: &mut fidl::encoding::Decoder<'_, D>,
3459 offset: usize,
3460 _depth: fidl::encoding::Depth,
3461 ) -> fidl::Result<()> {
3462 decoder.debug_check_bounds::<Self>(offset);
3463 fidl::decode!(ServiceInstance, D, &mut self.instance, decoder, offset + 0, _depth)?;
3465 Ok(())
3466 }
3467 }
3468
3469 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3470 type Borrowed<'a> = &'a Self;
3471 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3472 value
3473 }
3474 }
3475
3476 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnInstanceLostRequest {
3477 type Owned = Self;
3478
3479 #[inline(always)]
3480 fn inline_align(_context: fidl::encoding::Context) -> usize {
3481 8
3482 }
3483
3484 #[inline(always)]
3485 fn inline_size(_context: fidl::encoding::Context) -> usize {
3486 32
3487 }
3488 }
3489
3490 unsafe impl<D: fidl::encoding::ResourceDialect>
3491 fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D>
3492 for &ServiceSubscriptionListenerOnInstanceLostRequest
3493 {
3494 #[inline]
3495 unsafe fn encode(
3496 self,
3497 encoder: &mut fidl::encoding::Encoder<'_, D>,
3498 offset: usize,
3499 _depth: fidl::encoding::Depth,
3500 ) -> fidl::Result<()> {
3501 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3502 fidl::encoding::Encode::<ServiceSubscriptionListenerOnInstanceLostRequest, D>::encode(
3504 (
3505 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow(
3506 &self.service,
3507 ),
3508 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow(
3509 &self.instance,
3510 ),
3511 ),
3512 encoder,
3513 offset,
3514 _depth,
3515 )
3516 }
3517 }
3518 unsafe impl<
3519 D: fidl::encoding::ResourceDialect,
3520 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<22>, D>,
3521 T1: fidl::encoding::Encode<fidl::encoding::BoundedString<63>, D>,
3522 > fidl::encoding::Encode<ServiceSubscriptionListenerOnInstanceLostRequest, D> for (T0, T1)
3523 {
3524 #[inline]
3525 unsafe fn encode(
3526 self,
3527 encoder: &mut fidl::encoding::Encoder<'_, D>,
3528 offset: usize,
3529 depth: fidl::encoding::Depth,
3530 ) -> fidl::Result<()> {
3531 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnInstanceLostRequest>(offset);
3532 self.0.encode(encoder, offset + 0, depth)?;
3536 self.1.encode(encoder, offset + 16, depth)?;
3537 Ok(())
3538 }
3539 }
3540
3541 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3542 for ServiceSubscriptionListenerOnInstanceLostRequest
3543 {
3544 #[inline(always)]
3545 fn new_empty() -> Self {
3546 Self {
3547 service: fidl::new_empty!(fidl::encoding::BoundedString<22>, D),
3548 instance: fidl::new_empty!(fidl::encoding::BoundedString<63>, D),
3549 }
3550 }
3551
3552 #[inline]
3553 unsafe fn decode(
3554 &mut self,
3555 decoder: &mut fidl::encoding::Decoder<'_, D>,
3556 offset: usize,
3557 _depth: fidl::encoding::Depth,
3558 ) -> fidl::Result<()> {
3559 decoder.debug_check_bounds::<Self>(offset);
3560 fidl::decode!(
3562 fidl::encoding::BoundedString<22>,
3563 D,
3564 &mut self.service,
3565 decoder,
3566 offset + 0,
3567 _depth
3568 )?;
3569 fidl::decode!(
3570 fidl::encoding::BoundedString<63>,
3571 D,
3572 &mut self.instance,
3573 decoder,
3574 offset + 16,
3575 _depth
3576 )?;
3577 Ok(())
3578 }
3579 }
3580
3581 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3582 type Borrowed<'a> = &'a Self;
3583 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3584 value
3585 }
3586 }
3587
3588 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionListenerOnQueryRequest {
3589 type Owned = Self;
3590
3591 #[inline(always)]
3592 fn inline_align(_context: fidl::encoding::Context) -> usize {
3593 4
3594 }
3595
3596 #[inline(always)]
3597 fn inline_size(_context: fidl::encoding::Context) -> usize {
3598 4
3599 }
3600 }
3601
3602 unsafe impl<D: fidl::encoding::ResourceDialect>
3603 fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D>
3604 for &ServiceSubscriptionListenerOnQueryRequest
3605 {
3606 #[inline]
3607 unsafe fn encode(
3608 self,
3609 encoder: &mut fidl::encoding::Encoder<'_, D>,
3610 offset: usize,
3611 _depth: fidl::encoding::Depth,
3612 ) -> fidl::Result<()> {
3613 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3614 fidl::encoding::Encode::<ServiceSubscriptionListenerOnQueryRequest, D>::encode(
3616 (<ResourceType as fidl::encoding::ValueTypeMarker>::borrow(&self.resource_type),),
3617 encoder,
3618 offset,
3619 _depth,
3620 )
3621 }
3622 }
3623 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResourceType, D>>
3624 fidl::encoding::Encode<ServiceSubscriptionListenerOnQueryRequest, D> for (T0,)
3625 {
3626 #[inline]
3627 unsafe fn encode(
3628 self,
3629 encoder: &mut fidl::encoding::Encoder<'_, D>,
3630 offset: usize,
3631 depth: fidl::encoding::Depth,
3632 ) -> fidl::Result<()> {
3633 encoder.debug_check_bounds::<ServiceSubscriptionListenerOnQueryRequest>(offset);
3634 self.0.encode(encoder, offset + 0, depth)?;
3638 Ok(())
3639 }
3640 }
3641
3642 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3643 for ServiceSubscriptionListenerOnQueryRequest
3644 {
3645 #[inline(always)]
3646 fn new_empty() -> Self {
3647 Self { resource_type: fidl::new_empty!(ResourceType, D) }
3648 }
3649
3650 #[inline]
3651 unsafe fn decode(
3652 &mut self,
3653 decoder: &mut fidl::encoding::Decoder<'_, D>,
3654 offset: usize,
3655 _depth: fidl::encoding::Depth,
3656 ) -> fidl::Result<()> {
3657 decoder.debug_check_bounds::<Self>(offset);
3658 fidl::decode!(ResourceType, D, &mut self.resource_type, decoder, offset + 0, _depth)?;
3660 Ok(())
3661 }
3662 }
3663
3664 impl HostNameResolutionOptions {
3665 #[inline(always)]
3666 fn max_ordinal_present(&self) -> u64 {
3667 if let Some(_) = self.exclude_local_proxies {
3668 return 4;
3669 }
3670 if let Some(_) = self.exclude_local {
3671 return 3;
3672 }
3673 if let Some(_) = self.ip_versions {
3674 return 2;
3675 }
3676 if let Some(_) = self.media {
3677 return 1;
3678 }
3679 0
3680 }
3681 }
3682
3683 impl fidl::encoding::ValueTypeMarker for HostNameResolutionOptions {
3684 type Borrowed<'a> = &'a Self;
3685 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3686 value
3687 }
3688 }
3689
3690 unsafe impl fidl::encoding::TypeMarker for HostNameResolutionOptions {
3691 type Owned = Self;
3692
3693 #[inline(always)]
3694 fn inline_align(_context: fidl::encoding::Context) -> usize {
3695 8
3696 }
3697
3698 #[inline(always)]
3699 fn inline_size(_context: fidl::encoding::Context) -> usize {
3700 16
3701 }
3702 }
3703
3704 unsafe impl<D: fidl::encoding::ResourceDialect>
3705 fidl::encoding::Encode<HostNameResolutionOptions, D> for &HostNameResolutionOptions
3706 {
3707 unsafe fn encode(
3708 self,
3709 encoder: &mut fidl::encoding::Encoder<'_, D>,
3710 offset: usize,
3711 mut depth: fidl::encoding::Depth,
3712 ) -> fidl::Result<()> {
3713 encoder.debug_check_bounds::<HostNameResolutionOptions>(offset);
3714 let max_ordinal: u64 = self.max_ordinal_present();
3716 encoder.write_num(max_ordinal, offset);
3717 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3718 if max_ordinal == 0 {
3720 return Ok(());
3721 }
3722 depth.increment()?;
3723 let envelope_size = 8;
3724 let bytes_len = max_ordinal as usize * envelope_size;
3725 #[allow(unused_variables)]
3726 let offset = encoder.out_of_line_offset(bytes_len);
3727 let mut _prev_end_offset: usize = 0;
3728 if 1 > max_ordinal {
3729 return Ok(());
3730 }
3731
3732 let cur_offset: usize = (1 - 1) * envelope_size;
3735
3736 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3738
3739 fidl::encoding::encode_in_envelope_optional::<Media, D>(
3744 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
3745 encoder,
3746 offset + cur_offset,
3747 depth,
3748 )?;
3749
3750 _prev_end_offset = cur_offset + envelope_size;
3751 if 2 > max_ordinal {
3752 return Ok(());
3753 }
3754
3755 let cur_offset: usize = (2 - 1) * envelope_size;
3758
3759 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3761
3762 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
3767 self.ip_versions
3768 .as_ref()
3769 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
3770 encoder,
3771 offset + cur_offset,
3772 depth,
3773 )?;
3774
3775 _prev_end_offset = cur_offset + envelope_size;
3776 if 3 > max_ordinal {
3777 return Ok(());
3778 }
3779
3780 let cur_offset: usize = (3 - 1) * envelope_size;
3783
3784 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3786
3787 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3792 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3793 encoder,
3794 offset + cur_offset,
3795 depth,
3796 )?;
3797
3798 _prev_end_offset = cur_offset + envelope_size;
3799 if 4 > max_ordinal {
3800 return Ok(());
3801 }
3802
3803 let cur_offset: usize = (4 - 1) * envelope_size;
3806
3807 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3809
3810 fidl::encoding::encode_in_envelope_optional::<bool, D>(
3815 self.exclude_local_proxies
3816 .as_ref()
3817 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3818 encoder,
3819 offset + cur_offset,
3820 depth,
3821 )?;
3822
3823 _prev_end_offset = cur_offset + envelope_size;
3824
3825 Ok(())
3826 }
3827 }
3828
3829 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3830 for HostNameResolutionOptions
3831 {
3832 #[inline(always)]
3833 fn new_empty() -> Self {
3834 Self::default()
3835 }
3836
3837 unsafe fn decode(
3838 &mut self,
3839 decoder: &mut fidl::encoding::Decoder<'_, D>,
3840 offset: usize,
3841 mut depth: fidl::encoding::Depth,
3842 ) -> fidl::Result<()> {
3843 decoder.debug_check_bounds::<Self>(offset);
3844 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3845 None => return Err(fidl::Error::NotNullable),
3846 Some(len) => len,
3847 };
3848 if len == 0 {
3850 return Ok(());
3851 };
3852 depth.increment()?;
3853 let envelope_size = 8;
3854 let bytes_len = len * envelope_size;
3855 let offset = decoder.out_of_line_offset(bytes_len)?;
3856 let mut _next_ordinal_to_read = 0;
3858 let mut next_offset = offset;
3859 let end_offset = offset + bytes_len;
3860 _next_ordinal_to_read += 1;
3861 if next_offset >= end_offset {
3862 return Ok(());
3863 }
3864
3865 while _next_ordinal_to_read < 1 {
3867 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3868 _next_ordinal_to_read += 1;
3869 next_offset += envelope_size;
3870 }
3871
3872 let next_out_of_line = decoder.next_out_of_line();
3873 let handles_before = decoder.remaining_handles();
3874 if let Some((inlined, num_bytes, num_handles)) =
3875 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3876 {
3877 let member_inline_size =
3878 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3879 if inlined != (member_inline_size <= 4) {
3880 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3881 }
3882 let inner_offset;
3883 let mut inner_depth = depth.clone();
3884 if inlined {
3885 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3886 inner_offset = next_offset;
3887 } else {
3888 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3889 inner_depth.increment()?;
3890 }
3891 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
3892 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
3893 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3894 {
3895 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3896 }
3897 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3898 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3899 }
3900 }
3901
3902 next_offset += envelope_size;
3903 _next_ordinal_to_read += 1;
3904 if next_offset >= end_offset {
3905 return Ok(());
3906 }
3907
3908 while _next_ordinal_to_read < 2 {
3910 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3911 _next_ordinal_to_read += 1;
3912 next_offset += envelope_size;
3913 }
3914
3915 let next_out_of_line = decoder.next_out_of_line();
3916 let handles_before = decoder.remaining_handles();
3917 if let Some((inlined, num_bytes, num_handles)) =
3918 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3919 {
3920 let member_inline_size =
3921 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3922 if inlined != (member_inline_size <= 4) {
3923 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3924 }
3925 let inner_offset;
3926 let mut inner_depth = depth.clone();
3927 if inlined {
3928 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3929 inner_offset = next_offset;
3930 } else {
3931 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3932 inner_depth.increment()?;
3933 }
3934 let val_ref =
3935 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
3936 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
3937 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3938 {
3939 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3940 }
3941 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3942 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3943 }
3944 }
3945
3946 next_offset += envelope_size;
3947 _next_ordinal_to_read += 1;
3948 if next_offset >= end_offset {
3949 return Ok(());
3950 }
3951
3952 while _next_ordinal_to_read < 3 {
3954 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3955 _next_ordinal_to_read += 1;
3956 next_offset += envelope_size;
3957 }
3958
3959 let next_out_of_line = decoder.next_out_of_line();
3960 let handles_before = decoder.remaining_handles();
3961 if let Some((inlined, num_bytes, num_handles)) =
3962 fidl::encoding::decode_envelope_header(decoder, next_offset)?
3963 {
3964 let member_inline_size =
3965 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3966 if inlined != (member_inline_size <= 4) {
3967 return Err(fidl::Error::InvalidInlineBitInEnvelope);
3968 }
3969 let inner_offset;
3970 let mut inner_depth = depth.clone();
3971 if inlined {
3972 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3973 inner_offset = next_offset;
3974 } else {
3975 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3976 inner_depth.increment()?;
3977 }
3978 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
3979 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3980 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3981 {
3982 return Err(fidl::Error::InvalidNumBytesInEnvelope);
3983 }
3984 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3985 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3986 }
3987 }
3988
3989 next_offset += envelope_size;
3990 _next_ordinal_to_read += 1;
3991 if next_offset >= end_offset {
3992 return Ok(());
3993 }
3994
3995 while _next_ordinal_to_read < 4 {
3997 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3998 _next_ordinal_to_read += 1;
3999 next_offset += envelope_size;
4000 }
4001
4002 let next_out_of_line = decoder.next_out_of_line();
4003 let handles_before = decoder.remaining_handles();
4004 if let Some((inlined, num_bytes, num_handles)) =
4005 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4006 {
4007 let member_inline_size =
4008 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4009 if inlined != (member_inline_size <= 4) {
4010 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4011 }
4012 let inner_offset;
4013 let mut inner_depth = depth.clone();
4014 if inlined {
4015 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4016 inner_offset = next_offset;
4017 } else {
4018 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4019 inner_depth.increment()?;
4020 }
4021 let val_ref =
4022 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4023 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4024 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4025 {
4026 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4027 }
4028 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4029 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4030 }
4031 }
4032
4033 next_offset += envelope_size;
4034
4035 while next_offset < end_offset {
4037 _next_ordinal_to_read += 1;
4038 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4039 next_offset += envelope_size;
4040 }
4041
4042 Ok(())
4043 }
4044 }
4045
4046 impl HostNameSubscriptionOptions {
4047 #[inline(always)]
4048 fn max_ordinal_present(&self) -> u64 {
4049 if let Some(_) = self.exclude_local_proxies {
4050 return 4;
4051 }
4052 if let Some(_) = self.exclude_local {
4053 return 3;
4054 }
4055 if let Some(_) = self.ip_versions {
4056 return 2;
4057 }
4058 if let Some(_) = self.media {
4059 return 1;
4060 }
4061 0
4062 }
4063 }
4064
4065 impl fidl::encoding::ValueTypeMarker for HostNameSubscriptionOptions {
4066 type Borrowed<'a> = &'a Self;
4067 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4068 value
4069 }
4070 }
4071
4072 unsafe impl fidl::encoding::TypeMarker for HostNameSubscriptionOptions {
4073 type Owned = Self;
4074
4075 #[inline(always)]
4076 fn inline_align(_context: fidl::encoding::Context) -> usize {
4077 8
4078 }
4079
4080 #[inline(always)]
4081 fn inline_size(_context: fidl::encoding::Context) -> usize {
4082 16
4083 }
4084 }
4085
4086 unsafe impl<D: fidl::encoding::ResourceDialect>
4087 fidl::encoding::Encode<HostNameSubscriptionOptions, D> for &HostNameSubscriptionOptions
4088 {
4089 unsafe fn encode(
4090 self,
4091 encoder: &mut fidl::encoding::Encoder<'_, D>,
4092 offset: usize,
4093 mut depth: fidl::encoding::Depth,
4094 ) -> fidl::Result<()> {
4095 encoder.debug_check_bounds::<HostNameSubscriptionOptions>(offset);
4096 let max_ordinal: u64 = self.max_ordinal_present();
4098 encoder.write_num(max_ordinal, offset);
4099 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4100 if max_ordinal == 0 {
4102 return Ok(());
4103 }
4104 depth.increment()?;
4105 let envelope_size = 8;
4106 let bytes_len = max_ordinal as usize * envelope_size;
4107 #[allow(unused_variables)]
4108 let offset = encoder.out_of_line_offset(bytes_len);
4109 let mut _prev_end_offset: usize = 0;
4110 if 1 > max_ordinal {
4111 return Ok(());
4112 }
4113
4114 let cur_offset: usize = (1 - 1) * envelope_size;
4117
4118 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4120
4121 fidl::encoding::encode_in_envelope_optional::<Media, D>(
4126 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4127 encoder,
4128 offset + cur_offset,
4129 depth,
4130 )?;
4131
4132 _prev_end_offset = cur_offset + envelope_size;
4133 if 2 > max_ordinal {
4134 return Ok(());
4135 }
4136
4137 let cur_offset: usize = (2 - 1) * envelope_size;
4140
4141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4143
4144 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4149 self.ip_versions
4150 .as_ref()
4151 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4152 encoder,
4153 offset + cur_offset,
4154 depth,
4155 )?;
4156
4157 _prev_end_offset = cur_offset + envelope_size;
4158 if 3 > max_ordinal {
4159 return Ok(());
4160 }
4161
4162 let cur_offset: usize = (3 - 1) * envelope_size;
4165
4166 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4168
4169 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4174 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4175 encoder,
4176 offset + cur_offset,
4177 depth,
4178 )?;
4179
4180 _prev_end_offset = cur_offset + envelope_size;
4181 if 4 > max_ordinal {
4182 return Ok(());
4183 }
4184
4185 let cur_offset: usize = (4 - 1) * envelope_size;
4188
4189 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4191
4192 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4197 self.exclude_local_proxies
4198 .as_ref()
4199 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4200 encoder,
4201 offset + cur_offset,
4202 depth,
4203 )?;
4204
4205 _prev_end_offset = cur_offset + envelope_size;
4206
4207 Ok(())
4208 }
4209 }
4210
4211 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4212 for HostNameSubscriptionOptions
4213 {
4214 #[inline(always)]
4215 fn new_empty() -> Self {
4216 Self::default()
4217 }
4218
4219 unsafe fn decode(
4220 &mut self,
4221 decoder: &mut fidl::encoding::Decoder<'_, D>,
4222 offset: usize,
4223 mut depth: fidl::encoding::Depth,
4224 ) -> fidl::Result<()> {
4225 decoder.debug_check_bounds::<Self>(offset);
4226 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4227 None => return Err(fidl::Error::NotNullable),
4228 Some(len) => len,
4229 };
4230 if len == 0 {
4232 return Ok(());
4233 };
4234 depth.increment()?;
4235 let envelope_size = 8;
4236 let bytes_len = len * envelope_size;
4237 let offset = decoder.out_of_line_offset(bytes_len)?;
4238 let mut _next_ordinal_to_read = 0;
4240 let mut next_offset = offset;
4241 let end_offset = offset + bytes_len;
4242 _next_ordinal_to_read += 1;
4243 if next_offset >= end_offset {
4244 return Ok(());
4245 }
4246
4247 while _next_ordinal_to_read < 1 {
4249 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4250 _next_ordinal_to_read += 1;
4251 next_offset += envelope_size;
4252 }
4253
4254 let next_out_of_line = decoder.next_out_of_line();
4255 let handles_before = decoder.remaining_handles();
4256 if let Some((inlined, num_bytes, num_handles)) =
4257 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4258 {
4259 let member_inline_size =
4260 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4261 if inlined != (member_inline_size <= 4) {
4262 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4263 }
4264 let inner_offset;
4265 let mut inner_depth = depth.clone();
4266 if inlined {
4267 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4268 inner_offset = next_offset;
4269 } else {
4270 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4271 inner_depth.increment()?;
4272 }
4273 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4274 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4275 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4276 {
4277 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4278 }
4279 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4280 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4281 }
4282 }
4283
4284 next_offset += envelope_size;
4285 _next_ordinal_to_read += 1;
4286 if next_offset >= end_offset {
4287 return Ok(());
4288 }
4289
4290 while _next_ordinal_to_read < 2 {
4292 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4293 _next_ordinal_to_read += 1;
4294 next_offset += envelope_size;
4295 }
4296
4297 let next_out_of_line = decoder.next_out_of_line();
4298 let handles_before = decoder.remaining_handles();
4299 if let Some((inlined, num_bytes, num_handles)) =
4300 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4301 {
4302 let member_inline_size =
4303 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4304 if inlined != (member_inline_size <= 4) {
4305 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4306 }
4307 let inner_offset;
4308 let mut inner_depth = depth.clone();
4309 if inlined {
4310 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4311 inner_offset = next_offset;
4312 } else {
4313 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4314 inner_depth.increment()?;
4315 }
4316 let val_ref =
4317 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4318 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4319 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4320 {
4321 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4322 }
4323 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4324 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4325 }
4326 }
4327
4328 next_offset += envelope_size;
4329 _next_ordinal_to_read += 1;
4330 if next_offset >= end_offset {
4331 return Ok(());
4332 }
4333
4334 while _next_ordinal_to_read < 3 {
4336 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4337 _next_ordinal_to_read += 1;
4338 next_offset += envelope_size;
4339 }
4340
4341 let next_out_of_line = decoder.next_out_of_line();
4342 let handles_before = decoder.remaining_handles();
4343 if let Some((inlined, num_bytes, num_handles)) =
4344 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4345 {
4346 let member_inline_size =
4347 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4348 if inlined != (member_inline_size <= 4) {
4349 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4350 }
4351 let inner_offset;
4352 let mut inner_depth = depth.clone();
4353 if inlined {
4354 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4355 inner_offset = next_offset;
4356 } else {
4357 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4358 inner_depth.increment()?;
4359 }
4360 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
4361 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4362 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4363 {
4364 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4365 }
4366 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4367 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4368 }
4369 }
4370
4371 next_offset += envelope_size;
4372 _next_ordinal_to_read += 1;
4373 if next_offset >= end_offset {
4374 return Ok(());
4375 }
4376
4377 while _next_ordinal_to_read < 4 {
4379 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4380 _next_ordinal_to_read += 1;
4381 next_offset += envelope_size;
4382 }
4383
4384 let next_out_of_line = decoder.next_out_of_line();
4385 let handles_before = decoder.remaining_handles();
4386 if let Some((inlined, num_bytes, num_handles)) =
4387 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4388 {
4389 let member_inline_size =
4390 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4391 if inlined != (member_inline_size <= 4) {
4392 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4393 }
4394 let inner_offset;
4395 let mut inner_depth = depth.clone();
4396 if inlined {
4397 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4398 inner_offset = next_offset;
4399 } else {
4400 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4401 inner_depth.increment()?;
4402 }
4403 let val_ref =
4404 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
4405 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4406 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4407 {
4408 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4409 }
4410 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4411 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4412 }
4413 }
4414
4415 next_offset += envelope_size;
4416
4417 while next_offset < end_offset {
4419 _next_ordinal_to_read += 1;
4420 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4421 next_offset += envelope_size;
4422 }
4423
4424 Ok(())
4425 }
4426 }
4427
4428 impl ProxyHostPublicationOptions {
4429 #[inline(always)]
4430 fn max_ordinal_present(&self) -> u64 {
4431 if let Some(_) = self.perform_probe {
4432 return 3;
4433 }
4434 if let Some(_) = self.ip_versions {
4435 return 2;
4436 }
4437 if let Some(_) = self.media {
4438 return 1;
4439 }
4440 0
4441 }
4442 }
4443
4444 impl fidl::encoding::ValueTypeMarker for ProxyHostPublicationOptions {
4445 type Borrowed<'a> = &'a Self;
4446 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4447 value
4448 }
4449 }
4450
4451 unsafe impl fidl::encoding::TypeMarker for ProxyHostPublicationOptions {
4452 type Owned = Self;
4453
4454 #[inline(always)]
4455 fn inline_align(_context: fidl::encoding::Context) -> usize {
4456 8
4457 }
4458
4459 #[inline(always)]
4460 fn inline_size(_context: fidl::encoding::Context) -> usize {
4461 16
4462 }
4463 }
4464
4465 unsafe impl<D: fidl::encoding::ResourceDialect>
4466 fidl::encoding::Encode<ProxyHostPublicationOptions, D> for &ProxyHostPublicationOptions
4467 {
4468 unsafe fn encode(
4469 self,
4470 encoder: &mut fidl::encoding::Encoder<'_, D>,
4471 offset: usize,
4472 mut depth: fidl::encoding::Depth,
4473 ) -> fidl::Result<()> {
4474 encoder.debug_check_bounds::<ProxyHostPublicationOptions>(offset);
4475 let max_ordinal: u64 = self.max_ordinal_present();
4477 encoder.write_num(max_ordinal, offset);
4478 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4479 if max_ordinal == 0 {
4481 return Ok(());
4482 }
4483 depth.increment()?;
4484 let envelope_size = 8;
4485 let bytes_len = max_ordinal as usize * envelope_size;
4486 #[allow(unused_variables)]
4487 let offset = encoder.out_of_line_offset(bytes_len);
4488 let mut _prev_end_offset: usize = 0;
4489 if 1 > max_ordinal {
4490 return Ok(());
4491 }
4492
4493 let cur_offset: usize = (1 - 1) * envelope_size;
4496
4497 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4499
4500 fidl::encoding::encode_in_envelope_optional::<Media, D>(
4505 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
4506 encoder,
4507 offset + cur_offset,
4508 depth,
4509 )?;
4510
4511 _prev_end_offset = cur_offset + envelope_size;
4512 if 2 > max_ordinal {
4513 return Ok(());
4514 }
4515
4516 let cur_offset: usize = (2 - 1) * envelope_size;
4519
4520 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4522
4523 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
4528 self.ip_versions
4529 .as_ref()
4530 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
4531 encoder,
4532 offset + cur_offset,
4533 depth,
4534 )?;
4535
4536 _prev_end_offset = cur_offset + envelope_size;
4537 if 3 > max_ordinal {
4538 return Ok(());
4539 }
4540
4541 let cur_offset: usize = (3 - 1) * envelope_size;
4544
4545 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4547
4548 fidl::encoding::encode_in_envelope_optional::<bool, D>(
4553 self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4554 encoder,
4555 offset + cur_offset,
4556 depth,
4557 )?;
4558
4559 _prev_end_offset = cur_offset + envelope_size;
4560
4561 Ok(())
4562 }
4563 }
4564
4565 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4566 for ProxyHostPublicationOptions
4567 {
4568 #[inline(always)]
4569 fn new_empty() -> Self {
4570 Self::default()
4571 }
4572
4573 unsafe fn decode(
4574 &mut self,
4575 decoder: &mut fidl::encoding::Decoder<'_, D>,
4576 offset: usize,
4577 mut depth: fidl::encoding::Depth,
4578 ) -> fidl::Result<()> {
4579 decoder.debug_check_bounds::<Self>(offset);
4580 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4581 None => return Err(fidl::Error::NotNullable),
4582 Some(len) => len,
4583 };
4584 if len == 0 {
4586 return Ok(());
4587 };
4588 depth.increment()?;
4589 let envelope_size = 8;
4590 let bytes_len = len * envelope_size;
4591 let offset = decoder.out_of_line_offset(bytes_len)?;
4592 let mut _next_ordinal_to_read = 0;
4594 let mut next_offset = offset;
4595 let end_offset = offset + bytes_len;
4596 _next_ordinal_to_read += 1;
4597 if next_offset >= end_offset {
4598 return Ok(());
4599 }
4600
4601 while _next_ordinal_to_read < 1 {
4603 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4604 _next_ordinal_to_read += 1;
4605 next_offset += envelope_size;
4606 }
4607
4608 let next_out_of_line = decoder.next_out_of_line();
4609 let handles_before = decoder.remaining_handles();
4610 if let Some((inlined, num_bytes, num_handles)) =
4611 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4612 {
4613 let member_inline_size =
4614 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4615 if inlined != (member_inline_size <= 4) {
4616 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4617 }
4618 let inner_offset;
4619 let mut inner_depth = depth.clone();
4620 if inlined {
4621 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4622 inner_offset = next_offset;
4623 } else {
4624 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4625 inner_depth.increment()?;
4626 }
4627 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
4628 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
4629 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4630 {
4631 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4632 }
4633 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4634 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4635 }
4636 }
4637
4638 next_offset += envelope_size;
4639 _next_ordinal_to_read += 1;
4640 if next_offset >= end_offset {
4641 return Ok(());
4642 }
4643
4644 while _next_ordinal_to_read < 2 {
4646 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4647 _next_ordinal_to_read += 1;
4648 next_offset += envelope_size;
4649 }
4650
4651 let next_out_of_line = decoder.next_out_of_line();
4652 let handles_before = decoder.remaining_handles();
4653 if let Some((inlined, num_bytes, num_handles)) =
4654 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4655 {
4656 let member_inline_size =
4657 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4658 if inlined != (member_inline_size <= 4) {
4659 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4660 }
4661 let inner_offset;
4662 let mut inner_depth = depth.clone();
4663 if inlined {
4664 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4665 inner_offset = next_offset;
4666 } else {
4667 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4668 inner_depth.increment()?;
4669 }
4670 let val_ref =
4671 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
4672 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
4673 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4674 {
4675 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4676 }
4677 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4678 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4679 }
4680 }
4681
4682 next_offset += envelope_size;
4683 _next_ordinal_to_read += 1;
4684 if next_offset >= end_offset {
4685 return Ok(());
4686 }
4687
4688 while _next_ordinal_to_read < 3 {
4690 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4691 _next_ordinal_to_read += 1;
4692 next_offset += envelope_size;
4693 }
4694
4695 let next_out_of_line = decoder.next_out_of_line();
4696 let handles_before = decoder.remaining_handles();
4697 if let Some((inlined, num_bytes, num_handles)) =
4698 fidl::encoding::decode_envelope_header(decoder, next_offset)?
4699 {
4700 let member_inline_size =
4701 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4702 if inlined != (member_inline_size <= 4) {
4703 return Err(fidl::Error::InvalidInlineBitInEnvelope);
4704 }
4705 let inner_offset;
4706 let mut inner_depth = depth.clone();
4707 if inlined {
4708 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4709 inner_offset = next_offset;
4710 } else {
4711 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4712 inner_depth.increment()?;
4713 }
4714 let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
4715 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4716 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4717 {
4718 return Err(fidl::Error::InvalidNumBytesInEnvelope);
4719 }
4720 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4721 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4722 }
4723 }
4724
4725 next_offset += envelope_size;
4726
4727 while next_offset < end_offset {
4729 _next_ordinal_to_read += 1;
4730 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4731 next_offset += envelope_size;
4732 }
4733
4734 Ok(())
4735 }
4736 }
4737
4738 impl ServiceInstance {
4739 #[inline(always)]
4740 fn max_ordinal_present(&self) -> u64 {
4741 if let Some(_) = self.text_strings {
4742 return 10;
4743 }
4744 if let Some(_) = self.addresses {
4745 return 9;
4746 }
4747 if let Some(_) = self.target {
4748 return 8;
4749 }
4750 if let Some(_) = self.srv_weight {
4751 return 7;
4752 }
4753 if let Some(_) = self.srv_priority {
4754 return 6;
4755 }
4756 if let Some(_) = self.text {
4757 return 5;
4758 }
4759 if let Some(_) = self.ipv6_endpoint {
4760 return 4;
4761 }
4762 if let Some(_) = self.ipv4_endpoint {
4763 return 3;
4764 }
4765 if let Some(_) = self.instance {
4766 return 2;
4767 }
4768 if let Some(_) = self.service {
4769 return 1;
4770 }
4771 0
4772 }
4773 }
4774
4775 impl fidl::encoding::ValueTypeMarker for ServiceInstance {
4776 type Borrowed<'a> = &'a Self;
4777 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4778 value
4779 }
4780 }
4781
4782 unsafe impl fidl::encoding::TypeMarker for ServiceInstance {
4783 type Owned = Self;
4784
4785 #[inline(always)]
4786 fn inline_align(_context: fidl::encoding::Context) -> usize {
4787 8
4788 }
4789
4790 #[inline(always)]
4791 fn inline_size(_context: fidl::encoding::Context) -> usize {
4792 16
4793 }
4794 }
4795
4796 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceInstance, D>
4797 for &ServiceInstance
4798 {
4799 unsafe fn encode(
4800 self,
4801 encoder: &mut fidl::encoding::Encoder<'_, D>,
4802 offset: usize,
4803 mut depth: fidl::encoding::Depth,
4804 ) -> fidl::Result<()> {
4805 encoder.debug_check_bounds::<ServiceInstance>(offset);
4806 let max_ordinal: u64 = self.max_ordinal_present();
4808 encoder.write_num(max_ordinal, offset);
4809 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4810 if max_ordinal == 0 {
4812 return Ok(());
4813 }
4814 depth.increment()?;
4815 let envelope_size = 8;
4816 let bytes_len = max_ordinal as usize * envelope_size;
4817 #[allow(unused_variables)]
4818 let offset = encoder.out_of_line_offset(bytes_len);
4819 let mut _prev_end_offset: usize = 0;
4820 if 1 > max_ordinal {
4821 return Ok(());
4822 }
4823
4824 let cur_offset: usize = (1 - 1) * envelope_size;
4827
4828 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4830
4831 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<22>, D>(
4836 self.service.as_ref().map(
4837 <fidl::encoding::BoundedString<22> as fidl::encoding::ValueTypeMarker>::borrow,
4838 ),
4839 encoder,
4840 offset + cur_offset,
4841 depth,
4842 )?;
4843
4844 _prev_end_offset = cur_offset + envelope_size;
4845 if 2 > max_ordinal {
4846 return Ok(());
4847 }
4848
4849 let cur_offset: usize = (2 - 1) * envelope_size;
4852
4853 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4855
4856 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<63>, D>(
4861 self.instance.as_ref().map(
4862 <fidl::encoding::BoundedString<63> as fidl::encoding::ValueTypeMarker>::borrow,
4863 ),
4864 encoder,
4865 offset + cur_offset,
4866 depth,
4867 )?;
4868
4869 _prev_end_offset = cur_offset + envelope_size;
4870 if 3 > max_ordinal {
4871 return Ok(());
4872 }
4873
4874 let cur_offset: usize = (3 - 1) * envelope_size;
4877
4878 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4880
4881 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4SocketAddress, D>(
4886 self.ipv4_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4887 encoder, offset + cur_offset, depth
4888 )?;
4889
4890 _prev_end_offset = cur_offset + envelope_size;
4891 if 4 > max_ordinal {
4892 return Ok(());
4893 }
4894
4895 let cur_offset: usize = (4 - 1) * envelope_size;
4898
4899 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4901
4902 fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6SocketAddress, D>(
4907 self.ipv6_endpoint.as_ref().map(<fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::ValueTypeMarker>::borrow),
4908 encoder, offset + cur_offset, depth
4909 )?;
4910
4911 _prev_end_offset = cur_offset + envelope_size;
4912 if 5 > max_ordinal {
4913 return Ok(());
4914 }
4915
4916 let cur_offset: usize = (5 - 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::Vector<fidl::encoding::BoundedString<255>, 256>, D>(
4928 self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
4929 encoder, offset + cur_offset, depth
4930 )?;
4931
4932 _prev_end_offset = cur_offset + envelope_size;
4933 if 6 > max_ordinal {
4934 return Ok(());
4935 }
4936
4937 let cur_offset: usize = (6 - 1) * envelope_size;
4940
4941 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4943
4944 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4949 self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4950 encoder,
4951 offset + cur_offset,
4952 depth,
4953 )?;
4954
4955 _prev_end_offset = cur_offset + envelope_size;
4956 if 7 > max_ordinal {
4957 return Ok(());
4958 }
4959
4960 let cur_offset: usize = (7 - 1) * envelope_size;
4963
4964 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4966
4967 fidl::encoding::encode_in_envelope_optional::<u16, D>(
4972 self.srv_weight.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4973 encoder,
4974 offset + cur_offset,
4975 depth,
4976 )?;
4977
4978 _prev_end_offset = cur_offset + envelope_size;
4979 if 8 > max_ordinal {
4980 return Ok(());
4981 }
4982
4983 let cur_offset: usize = (8 - 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::BoundedString<255>, D>(
4995 self.target.as_ref().map(
4996 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
4997 ),
4998 encoder,
4999 offset + cur_offset,
5000 depth,
5001 )?;
5002
5003 _prev_end_offset = cur_offset + envelope_size;
5004 if 9 > max_ordinal {
5005 return Ok(());
5006 }
5007
5008 let cur_offset: usize = (9 - 1) * envelope_size;
5011
5012 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5014
5015 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D>(
5020 self.addresses.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5021 encoder, offset + cur_offset, depth
5022 )?;
5023
5024 _prev_end_offset = cur_offset + envelope_size;
5025 if 10 > max_ordinal {
5026 return Ok(());
5027 }
5028
5029 let cur_offset: usize = (10 - 1) * envelope_size;
5032
5033 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5035
5036 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5041 self.text_strings.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5042 encoder, offset + cur_offset, depth
5043 )?;
5044
5045 _prev_end_offset = cur_offset + envelope_size;
5046
5047 Ok(())
5048 }
5049 }
5050
5051 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceInstance {
5052 #[inline(always)]
5053 fn new_empty() -> Self {
5054 Self::default()
5055 }
5056
5057 unsafe fn decode(
5058 &mut self,
5059 decoder: &mut fidl::encoding::Decoder<'_, D>,
5060 offset: usize,
5061 mut depth: fidl::encoding::Depth,
5062 ) -> fidl::Result<()> {
5063 decoder.debug_check_bounds::<Self>(offset);
5064 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5065 None => return Err(fidl::Error::NotNullable),
5066 Some(len) => len,
5067 };
5068 if len == 0 {
5070 return Ok(());
5071 };
5072 depth.increment()?;
5073 let envelope_size = 8;
5074 let bytes_len = len * envelope_size;
5075 let offset = decoder.out_of_line_offset(bytes_len)?;
5076 let mut _next_ordinal_to_read = 0;
5078 let mut next_offset = offset;
5079 let end_offset = offset + bytes_len;
5080 _next_ordinal_to_read += 1;
5081 if next_offset >= end_offset {
5082 return Ok(());
5083 }
5084
5085 while _next_ordinal_to_read < 1 {
5087 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5088 _next_ordinal_to_read += 1;
5089 next_offset += envelope_size;
5090 }
5091
5092 let next_out_of_line = decoder.next_out_of_line();
5093 let handles_before = decoder.remaining_handles();
5094 if let Some((inlined, num_bytes, num_handles)) =
5095 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5096 {
5097 let member_inline_size =
5098 <fidl::encoding::BoundedString<22> as fidl::encoding::TypeMarker>::inline_size(
5099 decoder.context,
5100 );
5101 if inlined != (member_inline_size <= 4) {
5102 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5103 }
5104 let inner_offset;
5105 let mut inner_depth = depth.clone();
5106 if inlined {
5107 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5108 inner_offset = next_offset;
5109 } else {
5110 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5111 inner_depth.increment()?;
5112 }
5113 let val_ref = self
5114 .service
5115 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<22>, D));
5116 fidl::decode!(
5117 fidl::encoding::BoundedString<22>,
5118 D,
5119 val_ref,
5120 decoder,
5121 inner_offset,
5122 inner_depth
5123 )?;
5124 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5125 {
5126 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5127 }
5128 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5129 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5130 }
5131 }
5132
5133 next_offset += envelope_size;
5134 _next_ordinal_to_read += 1;
5135 if next_offset >= end_offset {
5136 return Ok(());
5137 }
5138
5139 while _next_ordinal_to_read < 2 {
5141 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5142 _next_ordinal_to_read += 1;
5143 next_offset += envelope_size;
5144 }
5145
5146 let next_out_of_line = decoder.next_out_of_line();
5147 let handles_before = decoder.remaining_handles();
5148 if let Some((inlined, num_bytes, num_handles)) =
5149 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5150 {
5151 let member_inline_size =
5152 <fidl::encoding::BoundedString<63> as fidl::encoding::TypeMarker>::inline_size(
5153 decoder.context,
5154 );
5155 if inlined != (member_inline_size <= 4) {
5156 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5157 }
5158 let inner_offset;
5159 let mut inner_depth = depth.clone();
5160 if inlined {
5161 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5162 inner_offset = next_offset;
5163 } else {
5164 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5165 inner_depth.increment()?;
5166 }
5167 let val_ref = self
5168 .instance
5169 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<63>, D));
5170 fidl::decode!(
5171 fidl::encoding::BoundedString<63>,
5172 D,
5173 val_ref,
5174 decoder,
5175 inner_offset,
5176 inner_depth
5177 )?;
5178 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5179 {
5180 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5181 }
5182 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5183 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5184 }
5185 }
5186
5187 next_offset += envelope_size;
5188 _next_ordinal_to_read += 1;
5189 if next_offset >= end_offset {
5190 return Ok(());
5191 }
5192
5193 while _next_ordinal_to_read < 3 {
5195 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5196 _next_ordinal_to_read += 1;
5197 next_offset += envelope_size;
5198 }
5199
5200 let next_out_of_line = decoder.next_out_of_line();
5201 let handles_before = decoder.remaining_handles();
5202 if let Some((inlined, num_bytes, num_handles)) =
5203 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5204 {
5205 let member_inline_size = <fidl_fuchsia_net__common::Ipv4SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5206 if inlined != (member_inline_size <= 4) {
5207 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5208 }
5209 let inner_offset;
5210 let mut inner_depth = depth.clone();
5211 if inlined {
5212 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5213 inner_offset = next_offset;
5214 } else {
5215 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5216 inner_depth.increment()?;
5217 }
5218 let val_ref = self.ipv4_endpoint.get_or_insert_with(|| {
5219 fidl::new_empty!(fidl_fuchsia_net__common::Ipv4SocketAddress, D)
5220 });
5221 fidl::decode!(
5222 fidl_fuchsia_net__common::Ipv4SocketAddress,
5223 D,
5224 val_ref,
5225 decoder,
5226 inner_offset,
5227 inner_depth
5228 )?;
5229 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5230 {
5231 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5232 }
5233 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5234 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5235 }
5236 }
5237
5238 next_offset += envelope_size;
5239 _next_ordinal_to_read += 1;
5240 if next_offset >= end_offset {
5241 return Ok(());
5242 }
5243
5244 while _next_ordinal_to_read < 4 {
5246 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5247 _next_ordinal_to_read += 1;
5248 next_offset += envelope_size;
5249 }
5250
5251 let next_out_of_line = decoder.next_out_of_line();
5252 let handles_before = decoder.remaining_handles();
5253 if let Some((inlined, num_bytes, num_handles)) =
5254 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5255 {
5256 let member_inline_size = <fidl_fuchsia_net__common::Ipv6SocketAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5257 if inlined != (member_inline_size <= 4) {
5258 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5259 }
5260 let inner_offset;
5261 let mut inner_depth = depth.clone();
5262 if inlined {
5263 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5264 inner_offset = next_offset;
5265 } else {
5266 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5267 inner_depth.increment()?;
5268 }
5269 let val_ref = self.ipv6_endpoint.get_or_insert_with(|| {
5270 fidl::new_empty!(fidl_fuchsia_net__common::Ipv6SocketAddress, D)
5271 });
5272 fidl::decode!(
5273 fidl_fuchsia_net__common::Ipv6SocketAddress,
5274 D,
5275 val_ref,
5276 decoder,
5277 inner_offset,
5278 inner_depth
5279 )?;
5280 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5281 {
5282 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5283 }
5284 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5285 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5286 }
5287 }
5288
5289 next_offset += envelope_size;
5290 _next_ordinal_to_read += 1;
5291 if next_offset >= end_offset {
5292 return Ok(());
5293 }
5294
5295 while _next_ordinal_to_read < 5 {
5297 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5298 _next_ordinal_to_read += 1;
5299 next_offset += envelope_size;
5300 }
5301
5302 let next_out_of_line = decoder.next_out_of_line();
5303 let handles_before = decoder.remaining_handles();
5304 if let Some((inlined, num_bytes, num_handles)) =
5305 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5306 {
5307 let member_inline_size = <fidl::encoding::Vector<
5308 fidl::encoding::BoundedString<255>,
5309 256,
5310 > as fidl::encoding::TypeMarker>::inline_size(
5311 decoder.context
5312 );
5313 if inlined != (member_inline_size <= 4) {
5314 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5315 }
5316 let inner_offset;
5317 let mut inner_depth = depth.clone();
5318 if inlined {
5319 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5320 inner_offset = next_offset;
5321 } else {
5322 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5323 inner_depth.increment()?;
5324 }
5325 let val_ref = self.text.get_or_insert_with(|| {
5326 fidl::new_empty!(
5327 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5328 D
5329 )
5330 });
5331 fidl::decode!(
5332 fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 256>,
5333 D,
5334 val_ref,
5335 decoder,
5336 inner_offset,
5337 inner_depth
5338 )?;
5339 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5340 {
5341 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5342 }
5343 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5344 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5345 }
5346 }
5347
5348 next_offset += envelope_size;
5349 _next_ordinal_to_read += 1;
5350 if next_offset >= end_offset {
5351 return Ok(());
5352 }
5353
5354 while _next_ordinal_to_read < 6 {
5356 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5357 _next_ordinal_to_read += 1;
5358 next_offset += envelope_size;
5359 }
5360
5361 let next_out_of_line = decoder.next_out_of_line();
5362 let handles_before = decoder.remaining_handles();
5363 if let Some((inlined, num_bytes, num_handles)) =
5364 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5365 {
5366 let member_inline_size =
5367 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5368 if inlined != (member_inline_size <= 4) {
5369 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5370 }
5371 let inner_offset;
5372 let mut inner_depth = depth.clone();
5373 if inlined {
5374 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5375 inner_offset = next_offset;
5376 } else {
5377 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5378 inner_depth.increment()?;
5379 }
5380 let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
5381 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5382 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5383 {
5384 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5385 }
5386 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5387 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5388 }
5389 }
5390
5391 next_offset += envelope_size;
5392 _next_ordinal_to_read += 1;
5393 if next_offset >= end_offset {
5394 return Ok(());
5395 }
5396
5397 while _next_ordinal_to_read < 7 {
5399 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5400 _next_ordinal_to_read += 1;
5401 next_offset += envelope_size;
5402 }
5403
5404 let next_out_of_line = decoder.next_out_of_line();
5405 let handles_before = decoder.remaining_handles();
5406 if let Some((inlined, num_bytes, num_handles)) =
5407 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5408 {
5409 let member_inline_size =
5410 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5411 if inlined != (member_inline_size <= 4) {
5412 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5413 }
5414 let inner_offset;
5415 let mut inner_depth = depth.clone();
5416 if inlined {
5417 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5418 inner_offset = next_offset;
5419 } else {
5420 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5421 inner_depth.increment()?;
5422 }
5423 let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
5424 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5425 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5426 {
5427 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5428 }
5429 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5430 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5431 }
5432 }
5433
5434 next_offset += envelope_size;
5435 _next_ordinal_to_read += 1;
5436 if next_offset >= end_offset {
5437 return Ok(());
5438 }
5439
5440 while _next_ordinal_to_read < 8 {
5442 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5443 _next_ordinal_to_read += 1;
5444 next_offset += envelope_size;
5445 }
5446
5447 let next_out_of_line = decoder.next_out_of_line();
5448 let handles_before = decoder.remaining_handles();
5449 if let Some((inlined, num_bytes, num_handles)) =
5450 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5451 {
5452 let member_inline_size =
5453 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
5454 decoder.context,
5455 );
5456 if inlined != (member_inline_size <= 4) {
5457 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5458 }
5459 let inner_offset;
5460 let mut inner_depth = depth.clone();
5461 if inlined {
5462 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5463 inner_offset = next_offset;
5464 } else {
5465 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5466 inner_depth.increment()?;
5467 }
5468 let val_ref = self
5469 .target
5470 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
5471 fidl::decode!(
5472 fidl::encoding::BoundedString<255>,
5473 D,
5474 val_ref,
5475 decoder,
5476 inner_offset,
5477 inner_depth
5478 )?;
5479 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5480 {
5481 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5482 }
5483 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5484 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5485 }
5486 }
5487
5488 next_offset += envelope_size;
5489 _next_ordinal_to_read += 1;
5490 if next_offset >= end_offset {
5491 return Ok(());
5492 }
5493
5494 while _next_ordinal_to_read < 9 {
5496 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5497 _next_ordinal_to_read += 1;
5498 next_offset += envelope_size;
5499 }
5500
5501 let next_out_of_line = decoder.next_out_of_line();
5502 let handles_before = decoder.remaining_handles();
5503 if let Some((inlined, num_bytes, num_handles)) =
5504 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5505 {
5506 let member_inline_size = <fidl::encoding::Vector<
5507 fidl_fuchsia_net__common::SocketAddress,
5508 64,
5509 > as fidl::encoding::TypeMarker>::inline_size(
5510 decoder.context
5511 );
5512 if inlined != (member_inline_size <= 4) {
5513 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5514 }
5515 let inner_offset;
5516 let mut inner_depth = depth.clone();
5517 if inlined {
5518 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5519 inner_offset = next_offset;
5520 } else {
5521 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5522 inner_depth.increment()?;
5523 }
5524 let val_ref =
5525 self.addresses.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D));
5526 fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::SocketAddress, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
5527 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5528 {
5529 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5530 }
5531 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5532 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5533 }
5534 }
5535
5536 next_offset += envelope_size;
5537 _next_ordinal_to_read += 1;
5538 if next_offset >= end_offset {
5539 return Ok(());
5540 }
5541
5542 while _next_ordinal_to_read < 10 {
5544 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5545 _next_ordinal_to_read += 1;
5546 next_offset += envelope_size;
5547 }
5548
5549 let next_out_of_line = decoder.next_out_of_line();
5550 let handles_before = decoder.remaining_handles();
5551 if let Some((inlined, num_bytes, num_handles)) =
5552 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5553 {
5554 let member_inline_size = <fidl::encoding::Vector<
5555 fidl::encoding::Vector<u8, 255>,
5556 256,
5557 > as fidl::encoding::TypeMarker>::inline_size(
5558 decoder.context
5559 );
5560 if inlined != (member_inline_size <= 4) {
5561 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5562 }
5563 let inner_offset;
5564 let mut inner_depth = depth.clone();
5565 if inlined {
5566 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5567 inner_offset = next_offset;
5568 } else {
5569 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5570 inner_depth.increment()?;
5571 }
5572 let val_ref = self.text_strings.get_or_insert_with(|| {
5573 fidl::new_empty!(
5574 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5575 D
5576 )
5577 });
5578 fidl::decode!(
5579 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5580 D,
5581 val_ref,
5582 decoder,
5583 inner_offset,
5584 inner_depth
5585 )?;
5586 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5587 {
5588 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5589 }
5590 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5591 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5592 }
5593 }
5594
5595 next_offset += envelope_size;
5596
5597 while next_offset < end_offset {
5599 _next_ordinal_to_read += 1;
5600 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5601 next_offset += envelope_size;
5602 }
5603
5604 Ok(())
5605 }
5606 }
5607
5608 impl ServiceInstancePublication {
5609 #[inline(always)]
5610 fn max_ordinal_present(&self) -> u64 {
5611 if let Some(_) = self.txt_ttl {
5612 return 7;
5613 }
5614 if let Some(_) = self.srv_ttl {
5615 return 6;
5616 }
5617 if let Some(_) = self.ptr_ttl {
5618 return 5;
5619 }
5620 if let Some(_) = self.srv_weight {
5621 return 4;
5622 }
5623 if let Some(_) = self.srv_priority {
5624 return 3;
5625 }
5626 if let Some(_) = self.text {
5627 return 2;
5628 }
5629 if let Some(_) = self.port {
5630 return 1;
5631 }
5632 0
5633 }
5634 }
5635
5636 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublication {
5637 type Borrowed<'a> = &'a Self;
5638 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5639 value
5640 }
5641 }
5642
5643 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublication {
5644 type Owned = Self;
5645
5646 #[inline(always)]
5647 fn inline_align(_context: fidl::encoding::Context) -> usize {
5648 8
5649 }
5650
5651 #[inline(always)]
5652 fn inline_size(_context: fidl::encoding::Context) -> usize {
5653 16
5654 }
5655 }
5656
5657 unsafe impl<D: fidl::encoding::ResourceDialect>
5658 fidl::encoding::Encode<ServiceInstancePublication, D> for &ServiceInstancePublication
5659 {
5660 unsafe fn encode(
5661 self,
5662 encoder: &mut fidl::encoding::Encoder<'_, D>,
5663 offset: usize,
5664 mut depth: fidl::encoding::Depth,
5665 ) -> fidl::Result<()> {
5666 encoder.debug_check_bounds::<ServiceInstancePublication>(offset);
5667 let max_ordinal: u64 = self.max_ordinal_present();
5669 encoder.write_num(max_ordinal, offset);
5670 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5671 if max_ordinal == 0 {
5673 return Ok(());
5674 }
5675 depth.increment()?;
5676 let envelope_size = 8;
5677 let bytes_len = max_ordinal as usize * envelope_size;
5678 #[allow(unused_variables)]
5679 let offset = encoder.out_of_line_offset(bytes_len);
5680 let mut _prev_end_offset: usize = 0;
5681 if 1 > max_ordinal {
5682 return Ok(());
5683 }
5684
5685 let cur_offset: usize = (1 - 1) * envelope_size;
5688
5689 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5691
5692 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5697 self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5698 encoder,
5699 offset + cur_offset,
5700 depth,
5701 )?;
5702
5703 _prev_end_offset = cur_offset + envelope_size;
5704 if 2 > max_ordinal {
5705 return Ok(());
5706 }
5707
5708 let cur_offset: usize = (2 - 1) * envelope_size;
5711
5712 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5714
5715 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>, D>(
5720 self.text.as_ref().map(<fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256> as fidl::encoding::ValueTypeMarker>::borrow),
5721 encoder, offset + cur_offset, depth
5722 )?;
5723
5724 _prev_end_offset = cur_offset + envelope_size;
5725 if 3 > max_ordinal {
5726 return Ok(());
5727 }
5728
5729 let cur_offset: usize = (3 - 1) * envelope_size;
5732
5733 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5735
5736 fidl::encoding::encode_in_envelope_optional::<u16, D>(
5741 self.srv_priority.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5742 encoder,
5743 offset + cur_offset,
5744 depth,
5745 )?;
5746
5747 _prev_end_offset = cur_offset + envelope_size;
5748 if 4 > max_ordinal {
5749 return Ok(());
5750 }
5751
5752 let cur_offset: usize = (4 - 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.srv_weight.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 5 > max_ordinal {
5772 return Ok(());
5773 }
5774
5775 let cur_offset: usize = (5 - 1) * envelope_size;
5778
5779 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5781
5782 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5787 self.ptr_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5788 encoder,
5789 offset + cur_offset,
5790 depth,
5791 )?;
5792
5793 _prev_end_offset = cur_offset + envelope_size;
5794 if 6 > max_ordinal {
5795 return Ok(());
5796 }
5797
5798 let cur_offset: usize = (6 - 1) * envelope_size;
5801
5802 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5804
5805 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5810 self.srv_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5811 encoder,
5812 offset + cur_offset,
5813 depth,
5814 )?;
5815
5816 _prev_end_offset = cur_offset + envelope_size;
5817 if 7 > max_ordinal {
5818 return Ok(());
5819 }
5820
5821 let cur_offset: usize = (7 - 1) * envelope_size;
5824
5825 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5827
5828 fidl::encoding::encode_in_envelope_optional::<i64, D>(
5833 self.txt_ttl.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5834 encoder,
5835 offset + cur_offset,
5836 depth,
5837 )?;
5838
5839 _prev_end_offset = cur_offset + envelope_size;
5840
5841 Ok(())
5842 }
5843 }
5844
5845 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5846 for ServiceInstancePublication
5847 {
5848 #[inline(always)]
5849 fn new_empty() -> Self {
5850 Self::default()
5851 }
5852
5853 unsafe fn decode(
5854 &mut self,
5855 decoder: &mut fidl::encoding::Decoder<'_, D>,
5856 offset: usize,
5857 mut depth: fidl::encoding::Depth,
5858 ) -> fidl::Result<()> {
5859 decoder.debug_check_bounds::<Self>(offset);
5860 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5861 None => return Err(fidl::Error::NotNullable),
5862 Some(len) => len,
5863 };
5864 if len == 0 {
5866 return Ok(());
5867 };
5868 depth.increment()?;
5869 let envelope_size = 8;
5870 let bytes_len = len * envelope_size;
5871 let offset = decoder.out_of_line_offset(bytes_len)?;
5872 let mut _next_ordinal_to_read = 0;
5874 let mut next_offset = offset;
5875 let end_offset = offset + bytes_len;
5876 _next_ordinal_to_read += 1;
5877 if next_offset >= end_offset {
5878 return Ok(());
5879 }
5880
5881 while _next_ordinal_to_read < 1 {
5883 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5884 _next_ordinal_to_read += 1;
5885 next_offset += envelope_size;
5886 }
5887
5888 let next_out_of_line = decoder.next_out_of_line();
5889 let handles_before = decoder.remaining_handles();
5890 if let Some((inlined, num_bytes, num_handles)) =
5891 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5892 {
5893 let member_inline_size =
5894 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5895 if inlined != (member_inline_size <= 4) {
5896 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5897 }
5898 let inner_offset;
5899 let mut inner_depth = depth.clone();
5900 if inlined {
5901 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5902 inner_offset = next_offset;
5903 } else {
5904 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5905 inner_depth.increment()?;
5906 }
5907 let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
5908 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5909 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5910 {
5911 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5912 }
5913 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5914 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5915 }
5916 }
5917
5918 next_offset += envelope_size;
5919 _next_ordinal_to_read += 1;
5920 if next_offset >= end_offset {
5921 return Ok(());
5922 }
5923
5924 while _next_ordinal_to_read < 2 {
5926 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5927 _next_ordinal_to_read += 1;
5928 next_offset += envelope_size;
5929 }
5930
5931 let next_out_of_line = decoder.next_out_of_line();
5932 let handles_before = decoder.remaining_handles();
5933 if let Some((inlined, num_bytes, num_handles)) =
5934 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5935 {
5936 let member_inline_size = <fidl::encoding::Vector<
5937 fidl::encoding::Vector<u8, 255>,
5938 256,
5939 > as fidl::encoding::TypeMarker>::inline_size(
5940 decoder.context
5941 );
5942 if inlined != (member_inline_size <= 4) {
5943 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5944 }
5945 let inner_offset;
5946 let mut inner_depth = depth.clone();
5947 if inlined {
5948 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5949 inner_offset = next_offset;
5950 } else {
5951 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5952 inner_depth.increment()?;
5953 }
5954 let val_ref = self.text.get_or_insert_with(|| {
5955 fidl::new_empty!(
5956 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5957 D
5958 )
5959 });
5960 fidl::decode!(
5961 fidl::encoding::Vector<fidl::encoding::Vector<u8, 255>, 256>,
5962 D,
5963 val_ref,
5964 decoder,
5965 inner_offset,
5966 inner_depth
5967 )?;
5968 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5969 {
5970 return Err(fidl::Error::InvalidNumBytesInEnvelope);
5971 }
5972 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5973 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5974 }
5975 }
5976
5977 next_offset += envelope_size;
5978 _next_ordinal_to_read += 1;
5979 if next_offset >= end_offset {
5980 return Ok(());
5981 }
5982
5983 while _next_ordinal_to_read < 3 {
5985 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5986 _next_ordinal_to_read += 1;
5987 next_offset += envelope_size;
5988 }
5989
5990 let next_out_of_line = decoder.next_out_of_line();
5991 let handles_before = decoder.remaining_handles();
5992 if let Some((inlined, num_bytes, num_handles)) =
5993 fidl::encoding::decode_envelope_header(decoder, next_offset)?
5994 {
5995 let member_inline_size =
5996 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5997 if inlined != (member_inline_size <= 4) {
5998 return Err(fidl::Error::InvalidInlineBitInEnvelope);
5999 }
6000 let inner_offset;
6001 let mut inner_depth = depth.clone();
6002 if inlined {
6003 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6004 inner_offset = next_offset;
6005 } else {
6006 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6007 inner_depth.increment()?;
6008 }
6009 let val_ref = self.srv_priority.get_or_insert_with(|| fidl::new_empty!(u16, D));
6010 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6011 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6012 {
6013 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6014 }
6015 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6016 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6017 }
6018 }
6019
6020 next_offset += envelope_size;
6021 _next_ordinal_to_read += 1;
6022 if next_offset >= end_offset {
6023 return Ok(());
6024 }
6025
6026 while _next_ordinal_to_read < 4 {
6028 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6029 _next_ordinal_to_read += 1;
6030 next_offset += envelope_size;
6031 }
6032
6033 let next_out_of_line = decoder.next_out_of_line();
6034 let handles_before = decoder.remaining_handles();
6035 if let Some((inlined, num_bytes, num_handles)) =
6036 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6037 {
6038 let member_inline_size =
6039 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6040 if inlined != (member_inline_size <= 4) {
6041 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6042 }
6043 let inner_offset;
6044 let mut inner_depth = depth.clone();
6045 if inlined {
6046 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6047 inner_offset = next_offset;
6048 } else {
6049 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6050 inner_depth.increment()?;
6051 }
6052 let val_ref = self.srv_weight.get_or_insert_with(|| fidl::new_empty!(u16, D));
6053 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6054 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6055 {
6056 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6057 }
6058 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6059 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6060 }
6061 }
6062
6063 next_offset += envelope_size;
6064 _next_ordinal_to_read += 1;
6065 if next_offset >= end_offset {
6066 return Ok(());
6067 }
6068
6069 while _next_ordinal_to_read < 5 {
6071 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6072 _next_ordinal_to_read += 1;
6073 next_offset += envelope_size;
6074 }
6075
6076 let next_out_of_line = decoder.next_out_of_line();
6077 let handles_before = decoder.remaining_handles();
6078 if let Some((inlined, num_bytes, num_handles)) =
6079 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6080 {
6081 let member_inline_size =
6082 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6083 if inlined != (member_inline_size <= 4) {
6084 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6085 }
6086 let inner_offset;
6087 let mut inner_depth = depth.clone();
6088 if inlined {
6089 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6090 inner_offset = next_offset;
6091 } else {
6092 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6093 inner_depth.increment()?;
6094 }
6095 let val_ref = self.ptr_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6096 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6097 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6098 {
6099 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6100 }
6101 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6102 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6103 }
6104 }
6105
6106 next_offset += envelope_size;
6107 _next_ordinal_to_read += 1;
6108 if next_offset >= end_offset {
6109 return Ok(());
6110 }
6111
6112 while _next_ordinal_to_read < 6 {
6114 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6115 _next_ordinal_to_read += 1;
6116 next_offset += envelope_size;
6117 }
6118
6119 let next_out_of_line = decoder.next_out_of_line();
6120 let handles_before = decoder.remaining_handles();
6121 if let Some((inlined, num_bytes, num_handles)) =
6122 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6123 {
6124 let member_inline_size =
6125 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6126 if inlined != (member_inline_size <= 4) {
6127 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6128 }
6129 let inner_offset;
6130 let mut inner_depth = depth.clone();
6131 if inlined {
6132 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6133 inner_offset = next_offset;
6134 } else {
6135 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6136 inner_depth.increment()?;
6137 }
6138 let val_ref = self.srv_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6139 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6140 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6141 {
6142 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6143 }
6144 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6145 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6146 }
6147 }
6148
6149 next_offset += envelope_size;
6150 _next_ordinal_to_read += 1;
6151 if next_offset >= end_offset {
6152 return Ok(());
6153 }
6154
6155 while _next_ordinal_to_read < 7 {
6157 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6158 _next_ordinal_to_read += 1;
6159 next_offset += envelope_size;
6160 }
6161
6162 let next_out_of_line = decoder.next_out_of_line();
6163 let handles_before = decoder.remaining_handles();
6164 if let Some((inlined, num_bytes, num_handles)) =
6165 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6166 {
6167 let member_inline_size =
6168 <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6169 if inlined != (member_inline_size <= 4) {
6170 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6171 }
6172 let inner_offset;
6173 let mut inner_depth = depth.clone();
6174 if inlined {
6175 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6176 inner_offset = next_offset;
6177 } else {
6178 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6179 inner_depth.increment()?;
6180 }
6181 let val_ref = self.txt_ttl.get_or_insert_with(|| fidl::new_empty!(i64, D));
6182 fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6183 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6184 {
6185 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6186 }
6187 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6188 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6189 }
6190 }
6191
6192 next_offset += envelope_size;
6193
6194 while next_offset < end_offset {
6196 _next_ordinal_to_read += 1;
6197 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6198 next_offset += envelope_size;
6199 }
6200
6201 Ok(())
6202 }
6203 }
6204
6205 impl ServiceInstancePublicationOptions {
6206 #[inline(always)]
6207 fn max_ordinal_present(&self) -> u64 {
6208 if let Some(_) = self.perform_probe {
6209 return 3;
6210 }
6211 if let Some(_) = self.ip_versions {
6212 return 2;
6213 }
6214 if let Some(_) = self.media {
6215 return 1;
6216 }
6217 0
6218 }
6219 }
6220
6221 impl fidl::encoding::ValueTypeMarker for ServiceInstancePublicationOptions {
6222 type Borrowed<'a> = &'a Self;
6223 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6224 value
6225 }
6226 }
6227
6228 unsafe impl fidl::encoding::TypeMarker for ServiceInstancePublicationOptions {
6229 type Owned = Self;
6230
6231 #[inline(always)]
6232 fn inline_align(_context: fidl::encoding::Context) -> usize {
6233 8
6234 }
6235
6236 #[inline(always)]
6237 fn inline_size(_context: fidl::encoding::Context) -> usize {
6238 16
6239 }
6240 }
6241
6242 unsafe impl<D: fidl::encoding::ResourceDialect>
6243 fidl::encoding::Encode<ServiceInstancePublicationOptions, D>
6244 for &ServiceInstancePublicationOptions
6245 {
6246 unsafe fn encode(
6247 self,
6248 encoder: &mut fidl::encoding::Encoder<'_, D>,
6249 offset: usize,
6250 mut depth: fidl::encoding::Depth,
6251 ) -> fidl::Result<()> {
6252 encoder.debug_check_bounds::<ServiceInstancePublicationOptions>(offset);
6253 let max_ordinal: u64 = self.max_ordinal_present();
6255 encoder.write_num(max_ordinal, offset);
6256 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6257 if max_ordinal == 0 {
6259 return Ok(());
6260 }
6261 depth.increment()?;
6262 let envelope_size = 8;
6263 let bytes_len = max_ordinal as usize * envelope_size;
6264 #[allow(unused_variables)]
6265 let offset = encoder.out_of_line_offset(bytes_len);
6266 let mut _prev_end_offset: usize = 0;
6267 if 1 > max_ordinal {
6268 return Ok(());
6269 }
6270
6271 let cur_offset: usize = (1 - 1) * envelope_size;
6274
6275 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6277
6278 fidl::encoding::encode_in_envelope_optional::<Media, D>(
6283 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6284 encoder,
6285 offset + cur_offset,
6286 depth,
6287 )?;
6288
6289 _prev_end_offset = cur_offset + envelope_size;
6290 if 2 > max_ordinal {
6291 return Ok(());
6292 }
6293
6294 let cur_offset: usize = (2 - 1) * envelope_size;
6297
6298 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6300
6301 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6306 self.ip_versions
6307 .as_ref()
6308 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6309 encoder,
6310 offset + cur_offset,
6311 depth,
6312 )?;
6313
6314 _prev_end_offset = cur_offset + envelope_size;
6315 if 3 > max_ordinal {
6316 return Ok(());
6317 }
6318
6319 let cur_offset: usize = (3 - 1) * envelope_size;
6322
6323 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6325
6326 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6331 self.perform_probe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6332 encoder,
6333 offset + cur_offset,
6334 depth,
6335 )?;
6336
6337 _prev_end_offset = cur_offset + envelope_size;
6338
6339 Ok(())
6340 }
6341 }
6342
6343 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6344 for ServiceInstancePublicationOptions
6345 {
6346 #[inline(always)]
6347 fn new_empty() -> Self {
6348 Self::default()
6349 }
6350
6351 unsafe fn decode(
6352 &mut self,
6353 decoder: &mut fidl::encoding::Decoder<'_, D>,
6354 offset: usize,
6355 mut depth: fidl::encoding::Depth,
6356 ) -> fidl::Result<()> {
6357 decoder.debug_check_bounds::<Self>(offset);
6358 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6359 None => return Err(fidl::Error::NotNullable),
6360 Some(len) => len,
6361 };
6362 if len == 0 {
6364 return Ok(());
6365 };
6366 depth.increment()?;
6367 let envelope_size = 8;
6368 let bytes_len = len * envelope_size;
6369 let offset = decoder.out_of_line_offset(bytes_len)?;
6370 let mut _next_ordinal_to_read = 0;
6372 let mut next_offset = offset;
6373 let end_offset = offset + bytes_len;
6374 _next_ordinal_to_read += 1;
6375 if next_offset >= end_offset {
6376 return Ok(());
6377 }
6378
6379 while _next_ordinal_to_read < 1 {
6381 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6382 _next_ordinal_to_read += 1;
6383 next_offset += envelope_size;
6384 }
6385
6386 let next_out_of_line = decoder.next_out_of_line();
6387 let handles_before = decoder.remaining_handles();
6388 if let Some((inlined, num_bytes, num_handles)) =
6389 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6390 {
6391 let member_inline_size =
6392 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6393 if inlined != (member_inline_size <= 4) {
6394 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6395 }
6396 let inner_offset;
6397 let mut inner_depth = depth.clone();
6398 if inlined {
6399 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6400 inner_offset = next_offset;
6401 } else {
6402 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6403 inner_depth.increment()?;
6404 }
6405 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6406 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6407 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6408 {
6409 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6410 }
6411 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6412 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6413 }
6414 }
6415
6416 next_offset += envelope_size;
6417 _next_ordinal_to_read += 1;
6418 if next_offset >= end_offset {
6419 return Ok(());
6420 }
6421
6422 while _next_ordinal_to_read < 2 {
6424 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6425 _next_ordinal_to_read += 1;
6426 next_offset += envelope_size;
6427 }
6428
6429 let next_out_of_line = decoder.next_out_of_line();
6430 let handles_before = decoder.remaining_handles();
6431 if let Some((inlined, num_bytes, num_handles)) =
6432 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6433 {
6434 let member_inline_size =
6435 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6436 if inlined != (member_inline_size <= 4) {
6437 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6438 }
6439 let inner_offset;
6440 let mut inner_depth = depth.clone();
6441 if inlined {
6442 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6443 inner_offset = next_offset;
6444 } else {
6445 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6446 inner_depth.increment()?;
6447 }
6448 let val_ref =
6449 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6450 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6451 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6452 {
6453 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6454 }
6455 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6456 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6457 }
6458 }
6459
6460 next_offset += envelope_size;
6461 _next_ordinal_to_read += 1;
6462 if next_offset >= end_offset {
6463 return Ok(());
6464 }
6465
6466 while _next_ordinal_to_read < 3 {
6468 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6469 _next_ordinal_to_read += 1;
6470 next_offset += envelope_size;
6471 }
6472
6473 let next_out_of_line = decoder.next_out_of_line();
6474 let handles_before = decoder.remaining_handles();
6475 if let Some((inlined, num_bytes, num_handles)) =
6476 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6477 {
6478 let member_inline_size =
6479 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6480 if inlined != (member_inline_size <= 4) {
6481 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6482 }
6483 let inner_offset;
6484 let mut inner_depth = depth.clone();
6485 if inlined {
6486 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6487 inner_offset = next_offset;
6488 } else {
6489 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6490 inner_depth.increment()?;
6491 }
6492 let val_ref = self.perform_probe.get_or_insert_with(|| fidl::new_empty!(bool, D));
6493 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6494 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6495 {
6496 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6497 }
6498 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6499 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6500 }
6501 }
6502
6503 next_offset += envelope_size;
6504
6505 while next_offset < end_offset {
6507 _next_ordinal_to_read += 1;
6508 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6509 next_offset += envelope_size;
6510 }
6511
6512 Ok(())
6513 }
6514 }
6515
6516 impl ServiceInstanceResolutionOptions {
6517 #[inline(always)]
6518 fn max_ordinal_present(&self) -> u64 {
6519 if let Some(_) = self.exclude_local_proxies {
6520 return 4;
6521 }
6522 if let Some(_) = self.exclude_local {
6523 return 3;
6524 }
6525 if let Some(_) = self.ip_versions {
6526 return 2;
6527 }
6528 if let Some(_) = self.media {
6529 return 1;
6530 }
6531 0
6532 }
6533 }
6534
6535 impl fidl::encoding::ValueTypeMarker for ServiceInstanceResolutionOptions {
6536 type Borrowed<'a> = &'a Self;
6537 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6538 value
6539 }
6540 }
6541
6542 unsafe impl fidl::encoding::TypeMarker for ServiceInstanceResolutionOptions {
6543 type Owned = Self;
6544
6545 #[inline(always)]
6546 fn inline_align(_context: fidl::encoding::Context) -> usize {
6547 8
6548 }
6549
6550 #[inline(always)]
6551 fn inline_size(_context: fidl::encoding::Context) -> usize {
6552 16
6553 }
6554 }
6555
6556 unsafe impl<D: fidl::encoding::ResourceDialect>
6557 fidl::encoding::Encode<ServiceInstanceResolutionOptions, D>
6558 for &ServiceInstanceResolutionOptions
6559 {
6560 unsafe fn encode(
6561 self,
6562 encoder: &mut fidl::encoding::Encoder<'_, D>,
6563 offset: usize,
6564 mut depth: fidl::encoding::Depth,
6565 ) -> fidl::Result<()> {
6566 encoder.debug_check_bounds::<ServiceInstanceResolutionOptions>(offset);
6567 let max_ordinal: u64 = self.max_ordinal_present();
6569 encoder.write_num(max_ordinal, offset);
6570 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6571 if max_ordinal == 0 {
6573 return Ok(());
6574 }
6575 depth.increment()?;
6576 let envelope_size = 8;
6577 let bytes_len = max_ordinal as usize * envelope_size;
6578 #[allow(unused_variables)]
6579 let offset = encoder.out_of_line_offset(bytes_len);
6580 let mut _prev_end_offset: usize = 0;
6581 if 1 > max_ordinal {
6582 return Ok(());
6583 }
6584
6585 let cur_offset: usize = (1 - 1) * envelope_size;
6588
6589 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6591
6592 fidl::encoding::encode_in_envelope_optional::<Media, D>(
6597 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6598 encoder,
6599 offset + cur_offset,
6600 depth,
6601 )?;
6602
6603 _prev_end_offset = cur_offset + envelope_size;
6604 if 2 > max_ordinal {
6605 return Ok(());
6606 }
6607
6608 let cur_offset: usize = (2 - 1) * envelope_size;
6611
6612 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6614
6615 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
6620 self.ip_versions
6621 .as_ref()
6622 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
6623 encoder,
6624 offset + cur_offset,
6625 depth,
6626 )?;
6627
6628 _prev_end_offset = cur_offset + envelope_size;
6629 if 3 > max_ordinal {
6630 return Ok(());
6631 }
6632
6633 let cur_offset: usize = (3 - 1) * envelope_size;
6636
6637 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6639
6640 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6645 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6646 encoder,
6647 offset + cur_offset,
6648 depth,
6649 )?;
6650
6651 _prev_end_offset = cur_offset + envelope_size;
6652 if 4 > max_ordinal {
6653 return Ok(());
6654 }
6655
6656 let cur_offset: usize = (4 - 1) * envelope_size;
6659
6660 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6662
6663 fidl::encoding::encode_in_envelope_optional::<bool, D>(
6668 self.exclude_local_proxies
6669 .as_ref()
6670 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6671 encoder,
6672 offset + cur_offset,
6673 depth,
6674 )?;
6675
6676 _prev_end_offset = cur_offset + envelope_size;
6677
6678 Ok(())
6679 }
6680 }
6681
6682 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6683 for ServiceInstanceResolutionOptions
6684 {
6685 #[inline(always)]
6686 fn new_empty() -> Self {
6687 Self::default()
6688 }
6689
6690 unsafe fn decode(
6691 &mut self,
6692 decoder: &mut fidl::encoding::Decoder<'_, D>,
6693 offset: usize,
6694 mut depth: fidl::encoding::Depth,
6695 ) -> fidl::Result<()> {
6696 decoder.debug_check_bounds::<Self>(offset);
6697 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6698 None => return Err(fidl::Error::NotNullable),
6699 Some(len) => len,
6700 };
6701 if len == 0 {
6703 return Ok(());
6704 };
6705 depth.increment()?;
6706 let envelope_size = 8;
6707 let bytes_len = len * envelope_size;
6708 let offset = decoder.out_of_line_offset(bytes_len)?;
6709 let mut _next_ordinal_to_read = 0;
6711 let mut next_offset = offset;
6712 let end_offset = offset + bytes_len;
6713 _next_ordinal_to_read += 1;
6714 if next_offset >= end_offset {
6715 return Ok(());
6716 }
6717
6718 while _next_ordinal_to_read < 1 {
6720 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6721 _next_ordinal_to_read += 1;
6722 next_offset += envelope_size;
6723 }
6724
6725 let next_out_of_line = decoder.next_out_of_line();
6726 let handles_before = decoder.remaining_handles();
6727 if let Some((inlined, num_bytes, num_handles)) =
6728 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6729 {
6730 let member_inline_size =
6731 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6732 if inlined != (member_inline_size <= 4) {
6733 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6734 }
6735 let inner_offset;
6736 let mut inner_depth = depth.clone();
6737 if inlined {
6738 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6739 inner_offset = next_offset;
6740 } else {
6741 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6742 inner_depth.increment()?;
6743 }
6744 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
6745 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
6746 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6747 {
6748 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6749 }
6750 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6751 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6752 }
6753 }
6754
6755 next_offset += envelope_size;
6756 _next_ordinal_to_read += 1;
6757 if next_offset >= end_offset {
6758 return Ok(());
6759 }
6760
6761 while _next_ordinal_to_read < 2 {
6763 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6764 _next_ordinal_to_read += 1;
6765 next_offset += envelope_size;
6766 }
6767
6768 let next_out_of_line = decoder.next_out_of_line();
6769 let handles_before = decoder.remaining_handles();
6770 if let Some((inlined, num_bytes, num_handles)) =
6771 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6772 {
6773 let member_inline_size =
6774 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6775 if inlined != (member_inline_size <= 4) {
6776 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6777 }
6778 let inner_offset;
6779 let mut inner_depth = depth.clone();
6780 if inlined {
6781 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6782 inner_offset = next_offset;
6783 } else {
6784 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6785 inner_depth.increment()?;
6786 }
6787 let val_ref =
6788 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
6789 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
6790 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6791 {
6792 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6793 }
6794 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6795 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6796 }
6797 }
6798
6799 next_offset += envelope_size;
6800 _next_ordinal_to_read += 1;
6801 if next_offset >= end_offset {
6802 return Ok(());
6803 }
6804
6805 while _next_ordinal_to_read < 3 {
6807 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6808 _next_ordinal_to_read += 1;
6809 next_offset += envelope_size;
6810 }
6811
6812 let next_out_of_line = decoder.next_out_of_line();
6813 let handles_before = decoder.remaining_handles();
6814 if let Some((inlined, num_bytes, num_handles)) =
6815 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6816 {
6817 let member_inline_size =
6818 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6819 if inlined != (member_inline_size <= 4) {
6820 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6821 }
6822 let inner_offset;
6823 let mut inner_depth = depth.clone();
6824 if inlined {
6825 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6826 inner_offset = next_offset;
6827 } else {
6828 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6829 inner_depth.increment()?;
6830 }
6831 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
6832 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6833 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6834 {
6835 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6836 }
6837 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6838 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6839 }
6840 }
6841
6842 next_offset += envelope_size;
6843 _next_ordinal_to_read += 1;
6844 if next_offset >= end_offset {
6845 return Ok(());
6846 }
6847
6848 while _next_ordinal_to_read < 4 {
6850 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6851 _next_ordinal_to_read += 1;
6852 next_offset += envelope_size;
6853 }
6854
6855 let next_out_of_line = decoder.next_out_of_line();
6856 let handles_before = decoder.remaining_handles();
6857 if let Some((inlined, num_bytes, num_handles)) =
6858 fidl::encoding::decode_envelope_header(decoder, next_offset)?
6859 {
6860 let member_inline_size =
6861 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6862 if inlined != (member_inline_size <= 4) {
6863 return Err(fidl::Error::InvalidInlineBitInEnvelope);
6864 }
6865 let inner_offset;
6866 let mut inner_depth = depth.clone();
6867 if inlined {
6868 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6869 inner_offset = next_offset;
6870 } else {
6871 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6872 inner_depth.increment()?;
6873 }
6874 let val_ref =
6875 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
6876 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6877 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6878 {
6879 return Err(fidl::Error::InvalidNumBytesInEnvelope);
6880 }
6881 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6882 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6883 }
6884 }
6885
6886 next_offset += envelope_size;
6887
6888 while next_offset < end_offset {
6890 _next_ordinal_to_read += 1;
6891 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6892 next_offset += envelope_size;
6893 }
6894
6895 Ok(())
6896 }
6897 }
6898
6899 impl ServiceSubscriptionOptions {
6900 #[inline(always)]
6901 fn max_ordinal_present(&self) -> u64 {
6902 if let Some(_) = self.exclude_local_proxies {
6903 return 4;
6904 }
6905 if let Some(_) = self.exclude_local {
6906 return 3;
6907 }
6908 if let Some(_) = self.ip_versions {
6909 return 2;
6910 }
6911 if let Some(_) = self.media {
6912 return 1;
6913 }
6914 0
6915 }
6916 }
6917
6918 impl fidl::encoding::ValueTypeMarker for ServiceSubscriptionOptions {
6919 type Borrowed<'a> = &'a Self;
6920 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6921 value
6922 }
6923 }
6924
6925 unsafe impl fidl::encoding::TypeMarker for ServiceSubscriptionOptions {
6926 type Owned = Self;
6927
6928 #[inline(always)]
6929 fn inline_align(_context: fidl::encoding::Context) -> usize {
6930 8
6931 }
6932
6933 #[inline(always)]
6934 fn inline_size(_context: fidl::encoding::Context) -> usize {
6935 16
6936 }
6937 }
6938
6939 unsafe impl<D: fidl::encoding::ResourceDialect>
6940 fidl::encoding::Encode<ServiceSubscriptionOptions, D> for &ServiceSubscriptionOptions
6941 {
6942 unsafe fn encode(
6943 self,
6944 encoder: &mut fidl::encoding::Encoder<'_, D>,
6945 offset: usize,
6946 mut depth: fidl::encoding::Depth,
6947 ) -> fidl::Result<()> {
6948 encoder.debug_check_bounds::<ServiceSubscriptionOptions>(offset);
6949 let max_ordinal: u64 = self.max_ordinal_present();
6951 encoder.write_num(max_ordinal, offset);
6952 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6953 if max_ordinal == 0 {
6955 return Ok(());
6956 }
6957 depth.increment()?;
6958 let envelope_size = 8;
6959 let bytes_len = max_ordinal as usize * envelope_size;
6960 #[allow(unused_variables)]
6961 let offset = encoder.out_of_line_offset(bytes_len);
6962 let mut _prev_end_offset: usize = 0;
6963 if 1 > max_ordinal {
6964 return Ok(());
6965 }
6966
6967 let cur_offset: usize = (1 - 1) * envelope_size;
6970
6971 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6973
6974 fidl::encoding::encode_in_envelope_optional::<Media, D>(
6979 self.media.as_ref().map(<Media as fidl::encoding::ValueTypeMarker>::borrow),
6980 encoder,
6981 offset + cur_offset,
6982 depth,
6983 )?;
6984
6985 _prev_end_offset = cur_offset + envelope_size;
6986 if 2 > max_ordinal {
6987 return Ok(());
6988 }
6989
6990 let cur_offset: usize = (2 - 1) * envelope_size;
6993
6994 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6996
6997 fidl::encoding::encode_in_envelope_optional::<IpVersions, D>(
7002 self.ip_versions
7003 .as_ref()
7004 .map(<IpVersions as fidl::encoding::ValueTypeMarker>::borrow),
7005 encoder,
7006 offset + cur_offset,
7007 depth,
7008 )?;
7009
7010 _prev_end_offset = cur_offset + envelope_size;
7011 if 3 > max_ordinal {
7012 return Ok(());
7013 }
7014
7015 let cur_offset: usize = (3 - 1) * envelope_size;
7018
7019 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7021
7022 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7027 self.exclude_local.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7028 encoder,
7029 offset + cur_offset,
7030 depth,
7031 )?;
7032
7033 _prev_end_offset = cur_offset + envelope_size;
7034 if 4 > max_ordinal {
7035 return Ok(());
7036 }
7037
7038 let cur_offset: usize = (4 - 1) * envelope_size;
7041
7042 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7044
7045 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7050 self.exclude_local_proxies
7051 .as_ref()
7052 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7053 encoder,
7054 offset + cur_offset,
7055 depth,
7056 )?;
7057
7058 _prev_end_offset = cur_offset + envelope_size;
7059
7060 Ok(())
7061 }
7062 }
7063
7064 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7065 for ServiceSubscriptionOptions
7066 {
7067 #[inline(always)]
7068 fn new_empty() -> Self {
7069 Self::default()
7070 }
7071
7072 unsafe fn decode(
7073 &mut self,
7074 decoder: &mut fidl::encoding::Decoder<'_, D>,
7075 offset: usize,
7076 mut depth: fidl::encoding::Depth,
7077 ) -> fidl::Result<()> {
7078 decoder.debug_check_bounds::<Self>(offset);
7079 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7080 None => return Err(fidl::Error::NotNullable),
7081 Some(len) => len,
7082 };
7083 if len == 0 {
7085 return Ok(());
7086 };
7087 depth.increment()?;
7088 let envelope_size = 8;
7089 let bytes_len = len * envelope_size;
7090 let offset = decoder.out_of_line_offset(bytes_len)?;
7091 let mut _next_ordinal_to_read = 0;
7093 let mut next_offset = offset;
7094 let end_offset = offset + bytes_len;
7095 _next_ordinal_to_read += 1;
7096 if next_offset >= end_offset {
7097 return Ok(());
7098 }
7099
7100 while _next_ordinal_to_read < 1 {
7102 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7103 _next_ordinal_to_read += 1;
7104 next_offset += envelope_size;
7105 }
7106
7107 let next_out_of_line = decoder.next_out_of_line();
7108 let handles_before = decoder.remaining_handles();
7109 if let Some((inlined, num_bytes, num_handles)) =
7110 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7111 {
7112 let member_inline_size =
7113 <Media as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7114 if inlined != (member_inline_size <= 4) {
7115 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7116 }
7117 let inner_offset;
7118 let mut inner_depth = depth.clone();
7119 if inlined {
7120 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7121 inner_offset = next_offset;
7122 } else {
7123 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7124 inner_depth.increment()?;
7125 }
7126 let val_ref = self.media.get_or_insert_with(|| fidl::new_empty!(Media, D));
7127 fidl::decode!(Media, D, val_ref, decoder, inner_offset, inner_depth)?;
7128 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7129 {
7130 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7131 }
7132 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7133 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7134 }
7135 }
7136
7137 next_offset += envelope_size;
7138 _next_ordinal_to_read += 1;
7139 if next_offset >= end_offset {
7140 return Ok(());
7141 }
7142
7143 while _next_ordinal_to_read < 2 {
7145 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7146 _next_ordinal_to_read += 1;
7147 next_offset += envelope_size;
7148 }
7149
7150 let next_out_of_line = decoder.next_out_of_line();
7151 let handles_before = decoder.remaining_handles();
7152 if let Some((inlined, num_bytes, num_handles)) =
7153 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7154 {
7155 let member_inline_size =
7156 <IpVersions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7157 if inlined != (member_inline_size <= 4) {
7158 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7159 }
7160 let inner_offset;
7161 let mut inner_depth = depth.clone();
7162 if inlined {
7163 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7164 inner_offset = next_offset;
7165 } else {
7166 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7167 inner_depth.increment()?;
7168 }
7169 let val_ref =
7170 self.ip_versions.get_or_insert_with(|| fidl::new_empty!(IpVersions, D));
7171 fidl::decode!(IpVersions, D, val_ref, decoder, inner_offset, inner_depth)?;
7172 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7173 {
7174 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7175 }
7176 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7177 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7178 }
7179 }
7180
7181 next_offset += envelope_size;
7182 _next_ordinal_to_read += 1;
7183 if next_offset >= end_offset {
7184 return Ok(());
7185 }
7186
7187 while _next_ordinal_to_read < 3 {
7189 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7190 _next_ordinal_to_read += 1;
7191 next_offset += envelope_size;
7192 }
7193
7194 let next_out_of_line = decoder.next_out_of_line();
7195 let handles_before = decoder.remaining_handles();
7196 if let Some((inlined, num_bytes, num_handles)) =
7197 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7198 {
7199 let member_inline_size =
7200 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7201 if inlined != (member_inline_size <= 4) {
7202 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7203 }
7204 let inner_offset;
7205 let mut inner_depth = depth.clone();
7206 if inlined {
7207 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7208 inner_offset = next_offset;
7209 } else {
7210 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7211 inner_depth.increment()?;
7212 }
7213 let val_ref = self.exclude_local.get_or_insert_with(|| fidl::new_empty!(bool, D));
7214 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7215 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7216 {
7217 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7218 }
7219 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7220 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7221 }
7222 }
7223
7224 next_offset += envelope_size;
7225 _next_ordinal_to_read += 1;
7226 if next_offset >= end_offset {
7227 return Ok(());
7228 }
7229
7230 while _next_ordinal_to_read < 4 {
7232 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7233 _next_ordinal_to_read += 1;
7234 next_offset += envelope_size;
7235 }
7236
7237 let next_out_of_line = decoder.next_out_of_line();
7238 let handles_before = decoder.remaining_handles();
7239 if let Some((inlined, num_bytes, num_handles)) =
7240 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7241 {
7242 let member_inline_size =
7243 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7244 if inlined != (member_inline_size <= 4) {
7245 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7246 }
7247 let inner_offset;
7248 let mut inner_depth = depth.clone();
7249 if inlined {
7250 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7251 inner_offset = next_offset;
7252 } else {
7253 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7254 inner_depth.increment()?;
7255 }
7256 let val_ref =
7257 self.exclude_local_proxies.get_or_insert_with(|| fidl::new_empty!(bool, D));
7258 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7259 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7260 {
7261 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7262 }
7263 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7264 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7265 }
7266 }
7267
7268 next_offset += envelope_size;
7269
7270 while next_offset < end_offset {
7272 _next_ordinal_to_read += 1;
7273 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7274 next_offset += envelope_size;
7275 }
7276
7277 Ok(())
7278 }
7279 }
7280}