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 const MAX_ATTRIBUTES: u64 = 131;
14
15pub const MAX_ATTRIBUTE_VALUES: u64 = 255;
18
19pub const MAX_ATTRIBUTE_VALUE_LENGTH: u64 = 65535;
22
23pub const MAX_CUSTOM_ATTRIBUTES: u64 = 127;
26
27pub const MAX_FILESYSTEM_ITEMS: u16 = 16;
32
33pub const MAX_MEDIA_PLAYER_ITEMS: u16 = 16;
38
39pub const MAX_NOTIFICATIONS: u8 = 255;
43
44pub const MAX_NOW_PLAYING_ITEMS: u16 = 16;
49
50pub const MAX_NUM_MEDIA_ATTRIBUTES: u8 = 8;
55
56bitflags! {
57 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
60 pub struct MajorPlayerType: u8 {
61 const AUDIO = 1;
62 const VIDEO = 2;
63 const BROADCASTING_AUDIO = 4;
64 const BROADCASTING_VIDEO = 8;
65 }
66}
67
68impl MajorPlayerType {}
69
70bitflags! {
71 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
73 pub struct Notifications: u32 {
74 const PLAYBACK_STATUS = 1;
76 const TRACK = 2;
78 const TRACK_POS = 4;
80 const BATT_STATUS = 8;
82 const SYSTEM_STATUS = 16;
84 const PLAYER_APPLICATION_SETTINGS = 32;
86 const ADDRESSED_PLAYER = 64;
88 const VOLUME = 128;
90 const AVAILABLE_PLAYERS = 256;
92 const CONNECTION = 65536;
94 }
95}
96
97impl Notifications {}
98
99bitflags! {
100 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
101 pub struct PlayerFeatureBits: u64 {
102 const SELECT = 72057594037927936;
103 const UP = 144115188075855872;
104 const DOWN = 288230376151711744;
105 const LEFT = 576460752303423488;
106 const RIGHT = 1152921504606846976;
107 const RIGHT_UP = 2305843009213693952;
108 const RIGHT_DOWN = 4611686018427387904;
109 const LEFT_UP = 9223372036854775808;
110 const LEFT_DOWN = 281474976710656;
111 const ROOT_MENU = 562949953421312;
112 const SETUP_MENU = 1125899906842624;
113 const CONTENTS_MENU = 2251799813685248;
114 const FAVORITE_MENU = 4503599627370496;
115 const EXIT = 9007199254740992;
116 const ZERO = 18014398509481984;
117 const ONE = 36028797018963968;
118 const TWO = 1099511627776;
119 const THREE = 2199023255552;
120 const FOUR = 4398046511104;
121 const FIVE = 8796093022208;
122 const SIX = 17592186044416;
123 const SEVEN = 35184372088832;
124 const EIGHT = 70368744177664;
125 const NINE = 140737488355328;
126 const DOT = 4294967296;
127 const ENTER = 8589934592;
128 const CLEAR = 17179869184;
129 const CHANNEL_UP = 34359738368;
130 const CHANNEL_DOWN = 68719476736;
131 const PREVIOUS_CHANNEL = 137438953472;
132 const SOUND_SELECT = 274877906944;
133 const INPUT_SELECT = 549755813888;
134 const DISPLAY_INFORMATION = 16777216;
135 const HELP = 33554432;
136 const PAGE_UP = 67108864;
137 const PAGE_DOWN = 134217728;
138 const POWER = 268435456;
139 const VOLUME_UP = 536870912;
140 const VOLUME_DOWN = 1073741824;
141 const MUTE = 2147483648;
142 const PLAY = 65536;
143 const STOP = 131072;
144 const PAUSE = 262144;
145 const RECORD = 524288;
146 const REWIND = 1048576;
147 const FAST_FORWARD = 2097152;
148 const EJECT = 4194304;
149 const FORWARD = 8388608;
150 const BACKWARD = 256;
151 const ANGLE = 512;
152 const SUBPICTURE = 1024;
153 const F1 = 2048;
154 const F2 = 4096;
155 const F3 = 8192;
156 const F4 = 16384;
157 const F5 = 32768;
158 const VENDOR_UNIQUE = 1;
159 const BASIC_GROUP_NAVIGATION = 2;
160 const ADVANCED_CONTROL_PLAYER = 4;
161 const BROWSING = 8;
162 const SEARCHING = 16;
163 const ADD_TO_NOW_PLAYING = 32;
164 const UIDS_UNIQUE_IN_PLAYER_BROWSE_TREE = 64;
165 const ONLY_BROWSABLE_WHEN_ADDRESSED = 128;
166 }
167}
168
169impl PlayerFeatureBits {}
170
171bitflags! {
172 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
173 pub struct PlayerFeatureBitsExt: u64 {
174 const ONLY_SEARCHABLE_WHEN_ADDRESSED = 72057594037927936;
175 const NOW_PLAYING = 144115188075855872;
176 const UID_PERSISTENCY = 288230376151711744;
177 const NUMBER_OF_ITEMS = 576460752303423488;
178 const COVER_ART = 1152921504606846976;
179 }
180}
181
182impl PlayerFeatureBitsExt {}
183
184bitflags! {
185 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
188 pub struct PlayerSubType: u32 {
189 const AUDIO_BOOK = 1;
190 const PODCAST = 2;
191 }
192}
193
194impl PlayerSubType {}
195
196#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
198#[repr(u8)]
199pub enum AvcPanelCommand {
200 Select = 0,
201 Up = 1,
202 Down = 2,
203 Left = 3,
204 Right = 4,
205 RootMenu = 9,
206 ContentsMenu = 11,
207 FavoriteMenu = 12,
208 Exit = 13,
209 OnDemandMenu = 14,
210 AppsMenu = 15,
211 Key0 = 32,
212 Key1 = 33,
213 Key2 = 34,
214 Key3 = 35,
215 Key4 = 36,
216 Key5 = 37,
217 Key6 = 38,
218 Key7 = 39,
219 Key8 = 40,
220 Key9 = 41,
221 Dot = 42,
222 Enter = 43,
223 ChannelUp = 48,
224 ChannelDown = 49,
225 ChannelPrevious = 50,
226 InputSelect = 52,
227 Info = 53,
228 Help = 54,
229 PageUp = 55,
230 PageDown = 56,
231 Lock = 58,
232 Power = 64,
233 VolumeUp = 65,
234 VolumeDown = 66,
235 Mute = 67,
236 Play = 68,
237 Stop = 69,
238 Pause = 70,
239 Record = 71,
240 Rewind = 72,
241 FastForward = 73,
242 Eject = 74,
243 Forward = 75,
244 Backward = 76,
245 List = 77,
246 F1 = 113,
247 F2 = 114,
248 F3 = 115,
249 F4 = 116,
250 F5 = 117,
251 F6 = 118,
252 F7 = 119,
253 F8 = 120,
254 F9 = 121,
255 Red = 122,
256 Green = 123,
257 Blue = 124,
258 Yellow = 125,
259}
260
261impl AvcPanelCommand {
262 #[inline]
263 pub fn from_primitive(prim: u8) -> Option<Self> {
264 match prim {
265 0 => Some(Self::Select),
266 1 => Some(Self::Up),
267 2 => Some(Self::Down),
268 3 => Some(Self::Left),
269 4 => Some(Self::Right),
270 9 => Some(Self::RootMenu),
271 11 => Some(Self::ContentsMenu),
272 12 => Some(Self::FavoriteMenu),
273 13 => Some(Self::Exit),
274 14 => Some(Self::OnDemandMenu),
275 15 => Some(Self::AppsMenu),
276 32 => Some(Self::Key0),
277 33 => Some(Self::Key1),
278 34 => Some(Self::Key2),
279 35 => Some(Self::Key3),
280 36 => Some(Self::Key4),
281 37 => Some(Self::Key5),
282 38 => Some(Self::Key6),
283 39 => Some(Self::Key7),
284 40 => Some(Self::Key8),
285 41 => Some(Self::Key9),
286 42 => Some(Self::Dot),
287 43 => Some(Self::Enter),
288 48 => Some(Self::ChannelUp),
289 49 => Some(Self::ChannelDown),
290 50 => Some(Self::ChannelPrevious),
291 52 => Some(Self::InputSelect),
292 53 => Some(Self::Info),
293 54 => Some(Self::Help),
294 55 => Some(Self::PageUp),
295 56 => Some(Self::PageDown),
296 58 => Some(Self::Lock),
297 64 => Some(Self::Power),
298 65 => Some(Self::VolumeUp),
299 66 => Some(Self::VolumeDown),
300 67 => Some(Self::Mute),
301 68 => Some(Self::Play),
302 69 => Some(Self::Stop),
303 70 => Some(Self::Pause),
304 71 => Some(Self::Record),
305 72 => Some(Self::Rewind),
306 73 => Some(Self::FastForward),
307 74 => Some(Self::Eject),
308 75 => Some(Self::Forward),
309 76 => Some(Self::Backward),
310 77 => Some(Self::List),
311 113 => Some(Self::F1),
312 114 => Some(Self::F2),
313 115 => Some(Self::F3),
314 116 => Some(Self::F4),
315 117 => Some(Self::F5),
316 118 => Some(Self::F6),
317 119 => Some(Self::F7),
318 120 => Some(Self::F8),
319 121 => Some(Self::F9),
320 122 => Some(Self::Red),
321 123 => Some(Self::Green),
322 124 => Some(Self::Blue),
323 125 => Some(Self::Yellow),
324 _ => None,
325 }
326 }
327
328 #[inline]
329 pub const fn into_primitive(self) -> u8 {
330 self as u8
331 }
332}
333
334#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
338#[repr(u8)]
339pub enum BatteryStatus {
340 Normal = 0,
341 Warning = 1,
342 Critical = 2,
343 External = 3,
344 FullCharge = 4,
345 Reserved = 5,
346}
347
348impl BatteryStatus {
349 #[inline]
350 pub fn from_primitive(prim: u8) -> Option<Self> {
351 match prim {
352 0 => Some(Self::Normal),
353 1 => Some(Self::Warning),
354 2 => Some(Self::Critical),
355 3 => Some(Self::External),
356 4 => Some(Self::FullCharge),
357 5 => Some(Self::Reserved),
358 _ => None,
359 }
360 }
361
362 #[inline]
363 pub const fn into_primitive(self) -> u8 {
364 self as u8
365 }
366}
367
368#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
370#[repr(u32)]
371pub enum BrowseControllerError {
372 UnknownFailure = 1,
373 TimedOut = 2,
374 RemoteNotConnected = 3,
375 CommandNotImplemented = 4,
376 CommandRejected = 5,
377 CommandUnexpected = 6,
378 PacketEncoding = 7,
379 ProtocolError = 8,
380 ConnectionError = 9,
381 UidChanged = 10,
382 InvalidDirection = 11,
383 InvalidId = 12,
384 InvalidScope = 13,
385 RangeOutOfBounds = 14,
386 ItemNotPlayable = 15,
387 MediaInUse = 16,
388 PlayerNotBrowsable = 17,
389 PlayerNotAddressed = 18,
390 NoValidResults = 19,
391 NoAvailablePlayers = 20,
392}
393
394impl BrowseControllerError {
395 #[inline]
396 pub fn from_primitive(prim: u32) -> Option<Self> {
397 match prim {
398 1 => Some(Self::UnknownFailure),
399 2 => Some(Self::TimedOut),
400 3 => Some(Self::RemoteNotConnected),
401 4 => Some(Self::CommandNotImplemented),
402 5 => Some(Self::CommandRejected),
403 6 => Some(Self::CommandUnexpected),
404 7 => Some(Self::PacketEncoding),
405 8 => Some(Self::ProtocolError),
406 9 => Some(Self::ConnectionError),
407 10 => Some(Self::UidChanged),
408 11 => Some(Self::InvalidDirection),
409 12 => Some(Self::InvalidId),
410 13 => Some(Self::InvalidScope),
411 14 => Some(Self::RangeOutOfBounds),
412 15 => Some(Self::ItemNotPlayable),
413 16 => Some(Self::MediaInUse),
414 17 => Some(Self::PlayerNotBrowsable),
415 18 => Some(Self::PlayerNotAddressed),
416 19 => Some(Self::NoValidResults),
417 20 => Some(Self::NoAvailablePlayers),
418 _ => None,
419 }
420 }
421
422 #[inline]
423 pub const fn into_primitive(self) -> u32 {
424 self as u32
425 }
426}
427
428#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
430#[repr(u32)]
431pub enum ControllerError {
432 UnknownFailure = 1,
433 TimedOut = 2,
434 RemoteNotConnected = 3,
435 CommandNotImplemented = 4,
436 CommandRejected = 5,
437 CommandUnexpected = 6,
438 InvalidArguments = 7,
439 PacketEncoding = 8,
440 ProtocolError = 9,
441 ConnectionError = 10,
442 UnexpectedResponse = 11,
443}
444
445impl ControllerError {
446 #[inline]
447 pub fn from_primitive(prim: u32) -> Option<Self> {
448 match prim {
449 1 => Some(Self::UnknownFailure),
450 2 => Some(Self::TimedOut),
451 3 => Some(Self::RemoteNotConnected),
452 4 => Some(Self::CommandNotImplemented),
453 5 => Some(Self::CommandRejected),
454 6 => Some(Self::CommandUnexpected),
455 7 => Some(Self::InvalidArguments),
456 8 => Some(Self::PacketEncoding),
457 9 => Some(Self::ProtocolError),
458 10 => Some(Self::ConnectionError),
459 11 => Some(Self::UnexpectedResponse),
460 _ => None,
461 }
462 }
463
464 #[inline]
465 pub const fn into_primitive(self) -> u32 {
466 self as u32
467 }
468}
469
470#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
472#[repr(u8)]
473pub enum Equalizer {
474 Off = 1,
475 On = 2,
476}
477
478impl Equalizer {
479 #[inline]
480 pub fn from_primitive(prim: u8) -> Option<Self> {
481 match prim {
482 1 => Some(Self::Off),
483 2 => Some(Self::On),
484 _ => None,
485 }
486 }
487
488 #[inline]
489 pub const fn into_primitive(self) -> u8 {
490 self as u8
491 }
492}
493
494#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
497#[repr(u8)]
498pub enum FolderType {
499 Mixed = 0,
500 Titles = 1,
501 Albums = 2,
502 Artists = 3,
503 Genres = 4,
504 Playlists = 5,
505 Years = 6,
506}
507
508impl FolderType {
509 #[inline]
510 pub fn from_primitive(prim: u8) -> Option<Self> {
511 match prim {
512 0 => Some(Self::Mixed),
513 1 => Some(Self::Titles),
514 2 => Some(Self::Albums),
515 3 => Some(Self::Artists),
516 4 => Some(Self::Genres),
517 5 => Some(Self::Playlists),
518 6 => Some(Self::Years),
519 _ => None,
520 }
521 }
522
523 #[inline]
524 pub const fn into_primitive(self) -> u8 {
525 self as u8
526 }
527}
528
529#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
532#[repr(u32)]
533pub enum MediaAttributeId {
534 Title = 1,
535 ArtistName = 2,
536 AlbumName = 3,
537 TrackNumber = 4,
538 TotalNumberOfTracks = 5,
539 Genre = 6,
540 PlayingTime = 7,
541 DefaultCoverArt = 8,
542}
543
544impl MediaAttributeId {
545 #[inline]
546 pub fn from_primitive(prim: u32) -> Option<Self> {
547 match prim {
548 1 => Some(Self::Title),
549 2 => Some(Self::ArtistName),
550 3 => Some(Self::AlbumName),
551 4 => Some(Self::TrackNumber),
552 5 => Some(Self::TotalNumberOfTracks),
553 6 => Some(Self::Genre),
554 7 => Some(Self::PlayingTime),
555 8 => Some(Self::DefaultCoverArt),
556 _ => None,
557 }
558 }
559
560 #[inline]
561 pub const fn into_primitive(self) -> u32 {
562 self as u32
563 }
564}
565
566#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
569#[repr(u8)]
570pub enum MediaType {
571 Audio = 0,
572 Video = 1,
573}
574
575impl MediaType {
576 #[inline]
577 pub fn from_primitive(prim: u8) -> Option<Self> {
578 match prim {
579 0 => Some(Self::Audio),
580 1 => Some(Self::Video),
581 _ => None,
582 }
583 }
584
585 #[inline]
586 pub const fn into_primitive(self) -> u8 {
587 self as u8
588 }
589}
590
591#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
594#[repr(u8)]
595pub enum NotificationEvent {
596 PlaybackStatusChanged = 1,
597 TrackChanged = 2,
598 TrackReachedEnd = 3,
599 TrackReachedStart = 4,
600 TrackPosChanged = 5,
601 BattStatusChanged = 6,
602 SystemStatusChanged = 7,
603 PlayerApplicationSettingChanged = 8,
604 NowPlayingContentChanged = 9,
605 AvailablePlayersChanged = 10,
606 AddressedPlayerChanged = 11,
607 UidsChanged = 12,
608 VolumeChanged = 13,
609}
610
611impl NotificationEvent {
612 #[inline]
613 pub fn from_primitive(prim: u8) -> Option<Self> {
614 match prim {
615 1 => Some(Self::PlaybackStatusChanged),
616 2 => Some(Self::TrackChanged),
617 3 => Some(Self::TrackReachedEnd),
618 4 => Some(Self::TrackReachedStart),
619 5 => Some(Self::TrackPosChanged),
620 6 => Some(Self::BattStatusChanged),
621 7 => Some(Self::SystemStatusChanged),
622 8 => Some(Self::PlayerApplicationSettingChanged),
623 9 => Some(Self::NowPlayingContentChanged),
624 10 => Some(Self::AvailablePlayersChanged),
625 11 => Some(Self::AddressedPlayerChanged),
626 12 => Some(Self::UidsChanged),
627 13 => Some(Self::VolumeChanged),
628 _ => None,
629 }
630 }
631
632 #[inline]
633 pub const fn into_primitive(self) -> u8 {
634 self as u8
635 }
636}
637
638#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
641#[repr(u8)]
642pub enum PlaybackStatus {
643 Stopped = 0,
644 Playing = 1,
645 Paused = 2,
646 FwdSeek = 3,
647 RevSeek = 4,
648 Error = 255,
649}
650
651impl PlaybackStatus {
652 #[inline]
653 pub fn from_primitive(prim: u8) -> Option<Self> {
654 match prim {
655 0 => Some(Self::Stopped),
656 1 => Some(Self::Playing),
657 2 => Some(Self::Paused),
658 3 => Some(Self::FwdSeek),
659 4 => Some(Self::RevSeek),
660 255 => Some(Self::Error),
661 _ => None,
662 }
663 }
664
665 #[inline]
666 pub const fn into_primitive(self) -> u8 {
667 self as u8
668 }
669}
670
671#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
674#[repr(u8)]
675pub enum PlayerApplicationSettingAttributeId {
676 Equalizer = 1,
677 RepeatStatusMode = 2,
678 ShuffleMode = 3,
679 ScanMode = 4,
680}
681
682impl PlayerApplicationSettingAttributeId {
683 #[inline]
684 pub fn from_primitive(prim: u8) -> Option<Self> {
685 match prim {
686 1 => Some(Self::Equalizer),
687 2 => Some(Self::RepeatStatusMode),
688 3 => Some(Self::ShuffleMode),
689 4 => Some(Self::ScanMode),
690 _ => None,
691 }
692 }
693
694 #[inline]
695 pub const fn into_primitive(self) -> u8 {
696 self as u8
697 }
698}
699
700#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
702#[repr(u8)]
703pub enum RepeatStatusMode {
704 Off = 1,
705 SingleTrackRepeat = 2,
706 AllTrackRepeat = 3,
707 GroupRepeat = 4,
708}
709
710impl RepeatStatusMode {
711 #[inline]
712 pub fn from_primitive(prim: u8) -> Option<Self> {
713 match prim {
714 1 => Some(Self::Off),
715 2 => Some(Self::SingleTrackRepeat),
716 3 => Some(Self::AllTrackRepeat),
717 4 => Some(Self::GroupRepeat),
718 _ => None,
719 }
720 }
721
722 #[inline]
723 pub const fn into_primitive(self) -> u8 {
724 self as u8
725 }
726}
727
728#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
730#[repr(u8)]
731pub enum ScanMode {
732 Off = 1,
733 AllTrackScan = 2,
734 GroupScan = 3,
735}
736
737impl ScanMode {
738 #[inline]
739 pub fn from_primitive(prim: u8) -> Option<Self> {
740 match prim {
741 1 => Some(Self::Off),
742 2 => Some(Self::AllTrackScan),
743 3 => Some(Self::GroupScan),
744 _ => None,
745 }
746 }
747
748 #[inline]
749 pub const fn into_primitive(self) -> u8 {
750 self as u8
751 }
752}
753
754#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
756#[repr(u8)]
757pub enum ShuffleMode {
758 Off = 1,
759 AllTrackShuffle = 2,
760 GroupShuffle = 3,
761}
762
763impl ShuffleMode {
764 #[inline]
765 pub fn from_primitive(prim: u8) -> Option<Self> {
766 match prim {
767 1 => Some(Self::Off),
768 2 => Some(Self::AllTrackShuffle),
769 3 => Some(Self::GroupShuffle),
770 _ => None,
771 }
772 }
773
774 #[inline]
775 pub const fn into_primitive(self) -> u8 {
776 self as u8
777 }
778}
779
780#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
783#[repr(u8)]
784pub enum SystemStatus {
785 PowerOn = 0,
786 PowerOff = 1,
787 Unplugged = 2,
788}
789
790impl SystemStatus {
791 #[inline]
792 pub fn from_primitive(prim: u8) -> Option<Self> {
793 match prim {
794 0 => Some(Self::PowerOn),
795 1 => Some(Self::PowerOff),
796 2 => Some(Self::Unplugged),
797 _ => None,
798 }
799 }
800
801 #[inline]
802 pub const fn into_primitive(self) -> u8 {
803 self as u8
804 }
805}
806
807#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
811#[repr(u32)]
812pub enum TargetAvcError {
813 RejectedInvalidCommand = 0,
814 RejectedInvalidParameter = 1,
815 RejectedParameterContentError = 2,
816 RejectedInternalError = 3,
817 RejectedUidChanged = 5,
818 RejectedInvalidPlayerId = 17,
819 RejectedNoAvailablePlayers = 21,
820 RejectedAddressedPlayerChanged = 22,
821}
822
823impl TargetAvcError {
824 #[inline]
825 pub fn from_primitive(prim: u32) -> Option<Self> {
826 match prim {
827 0 => Some(Self::RejectedInvalidCommand),
828 1 => Some(Self::RejectedInvalidParameter),
829 2 => Some(Self::RejectedParameterContentError),
830 3 => Some(Self::RejectedInternalError),
831 5 => Some(Self::RejectedUidChanged),
832 17 => Some(Self::RejectedInvalidPlayerId),
833 21 => Some(Self::RejectedNoAvailablePlayers),
834 22 => Some(Self::RejectedAddressedPlayerChanged),
835 _ => None,
836 }
837 }
838
839 #[inline]
840 pub const fn into_primitive(self) -> u32 {
841 self as u32
842 }
843}
844
845#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
847#[repr(u32)]
848pub enum TargetPassthroughError {
849 CommandNotImplemented = 1,
850 CommandRejected = 2,
851}
852
853impl TargetPassthroughError {
854 #[inline]
855 pub fn from_primitive(prim: u32) -> Option<Self> {
856 match prim {
857 1 => Some(Self::CommandNotImplemented),
858 2 => Some(Self::CommandRejected),
859 _ => None,
860 }
861 }
862
863 #[inline]
864 pub const fn into_primitive(self) -> u32 {
865 self as u32
866 }
867}
868
869#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
870#[repr(C)]
871pub struct AbsoluteVolumeHandlerGetCurrentVolumeResponse {
872 pub volume: u8,
873}
874
875impl fidl::Persistable for AbsoluteVolumeHandlerGetCurrentVolumeResponse {}
876
877#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
878#[repr(C)]
879pub struct AbsoluteVolumeHandlerOnVolumeChangedResponse {
880 pub new_volume: u8,
881}
882
883impl fidl::Persistable for AbsoluteVolumeHandlerOnVolumeChangedResponse {}
884
885#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
886#[repr(C)]
887pub struct AbsoluteVolumeHandlerSetVolumeRequest {
888 pub requested_volume: u8,
889}
890
891impl fidl::Persistable for AbsoluteVolumeHandlerSetVolumeRequest {}
892
893#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
894#[repr(C)]
895pub struct AbsoluteVolumeHandlerSetVolumeResponse {
896 pub set_volume: u8,
897}
898
899impl fidl::Persistable for AbsoluteVolumeHandlerSetVolumeResponse {}
900
901#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
907#[repr(C)]
908pub struct AddressedPlayerId {
909 pub id: u16,
910}
911
912impl fidl::Persistable for AddressedPlayerId {}
913
914#[derive(Clone, Debug, PartialEq)]
915pub struct BrowseControllerChangePathRequest {
916 pub path: Path,
917}
918
919impl fidl::Persistable for BrowseControllerChangePathRequest {}
920
921#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
922pub struct BrowseControllerGetFileSystemItemsRequest {
923 pub start_index: u32,
924 pub end_index: u32,
925 pub attribute_option: AttributeRequestOption,
926}
927
928impl fidl::Persistable for BrowseControllerGetFileSystemItemsRequest {}
929
930#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
931#[repr(C)]
932pub struct BrowseControllerGetMediaPlayerItemsRequest {
933 pub start_index: u32,
934 pub end_index: u32,
935}
936
937impl fidl::Persistable for BrowseControllerGetMediaPlayerItemsRequest {}
938
939#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
940pub struct BrowseControllerGetNowPlayingItemsRequest {
941 pub start_index: u32,
942 pub end_index: u32,
943 pub attribute_option: AttributeRequestOption,
944}
945
946impl fidl::Persistable for BrowseControllerGetNowPlayingItemsRequest {}
947
948#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
949#[repr(C)]
950pub struct BrowseControllerPlayFileSystemItemRequest {
951 pub uid: u64,
953}
954
955impl fidl::Persistable for BrowseControllerPlayFileSystemItemRequest {}
956
957#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
958#[repr(C)]
959pub struct BrowseControllerPlayNowPlayingItemRequest {
960 pub uid: u64,
961}
962
963impl fidl::Persistable for BrowseControllerPlayNowPlayingItemRequest {}
964
965#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
966#[repr(C)]
967pub struct BrowseControllerSetBrowsedPlayerRequest {
968 pub player_id: u16,
969}
970
971impl fidl::Persistable for BrowseControllerSetBrowsedPlayerRequest {}
972
973#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
974#[repr(C)]
975pub struct BrowseControllerChangePathResponse {
976 pub num_items: u32,
977}
978
979impl fidl::Persistable for BrowseControllerChangePathResponse {}
980
981#[derive(Clone, Debug, PartialEq)]
982pub struct BrowseControllerGetFileSystemItemsResponse {
983 pub items: Vec<FileSystemItem>,
984}
985
986impl fidl::Persistable for BrowseControllerGetFileSystemItemsResponse {}
987
988#[derive(Clone, Debug, PartialEq)]
989pub struct BrowseControllerGetMediaPlayerItemsResponse {
990 pub items: Vec<MediaPlayerItem>,
991}
992
993impl fidl::Persistable for BrowseControllerGetMediaPlayerItemsResponse {}
994
995#[derive(Clone, Debug, PartialEq)]
996pub struct BrowseControllerGetNowPlayingItemsResponse {
997 pub items: Vec<MediaElementItem>,
998}
999
1000impl fidl::Persistable for BrowseControllerGetNowPlayingItemsResponse {}
1001
1002#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1003pub struct ControllerGetPlayerApplicationSettingsRequest {
1004 pub attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
1005}
1006
1007impl fidl::Persistable for ControllerGetPlayerApplicationSettingsRequest {}
1008
1009#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1010pub struct ControllerInformBatteryStatusRequest {
1011 pub battery_status: BatteryStatus,
1012}
1013
1014impl fidl::Persistable for ControllerInformBatteryStatusRequest {}
1015
1016#[derive(Clone, Debug, PartialEq)]
1017pub struct ControllerOnNotificationRequest {
1018 pub timestamp: i64,
1019 pub notification: Notification,
1020}
1021
1022impl fidl::Persistable for ControllerOnNotificationRequest {}
1023
1024#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1025pub struct ControllerSendCommandRequest {
1026 pub command: AvcPanelCommand,
1027}
1028
1029impl fidl::Persistable for ControllerSendCommandRequest {}
1030
1031#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1032#[repr(C)]
1033pub struct ControllerSetAbsoluteVolumeRequest {
1034 pub requested_volume: u8,
1035}
1036
1037impl fidl::Persistable for ControllerSetAbsoluteVolumeRequest {}
1038
1039#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1040#[repr(C)]
1041pub struct ControllerSetAddressedPlayerRequest {
1042 pub player_id: u16,
1043}
1044
1045impl fidl::Persistable for ControllerSetAddressedPlayerRequest {}
1046
1047#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1048pub struct ControllerSetNotificationFilterRequest {
1049 pub notifications: Notifications,
1050 pub position_change_interval: u32,
1051}
1052
1053impl fidl::Persistable for ControllerSetNotificationFilterRequest {}
1054
1055#[derive(Clone, Debug, PartialEq)]
1056pub struct ControllerSetPlayerApplicationSettingsRequest {
1057 pub requested_settings: PlayerApplicationSettings,
1058}
1059
1060impl fidl::Persistable for ControllerSetPlayerApplicationSettingsRequest {}
1061
1062#[derive(Clone, Debug, PartialEq)]
1063pub struct ControllerGetMediaAttributesResponse {
1064 pub attributes: MediaAttributes,
1065}
1066
1067impl fidl::Persistable for ControllerGetMediaAttributesResponse {}
1068
1069#[derive(Clone, Debug, PartialEq)]
1070pub struct ControllerGetPlayStatusResponse {
1071 pub play_status: PlayStatus,
1072}
1073
1074impl fidl::Persistable for ControllerGetPlayStatusResponse {}
1075
1076#[derive(Clone, Debug, PartialEq)]
1077pub struct ControllerGetPlayerApplicationSettingsResponse {
1078 pub current_settings: PlayerApplicationSettings,
1079}
1080
1081impl fidl::Persistable for ControllerGetPlayerApplicationSettingsResponse {}
1082
1083#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1084#[repr(C)]
1085pub struct ControllerSetAbsoluteVolumeResponse {
1086 pub set_volume: u8,
1087}
1088
1089impl fidl::Persistable for ControllerSetAbsoluteVolumeResponse {}
1090
1091#[derive(Clone, Debug, PartialEq)]
1092pub struct ControllerSetPlayerApplicationSettingsResponse {
1093 pub set_settings: PlayerApplicationSettings,
1094}
1095
1096impl fidl::Persistable for ControllerSetPlayerApplicationSettingsResponse {}
1097
1098#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1100pub struct CustomAttributeValue {
1101 pub description: String,
1102 pub value: u8,
1103}
1104
1105impl fidl::Persistable for CustomAttributeValue {}
1106
1107#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1108pub struct Parent;
1109
1110impl fidl::Persistable for Parent {}
1111
1112#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1113pub struct TargetHandlerGetNotificationRequest {
1114 pub event_id: NotificationEvent,
1115}
1116
1117impl fidl::Persistable for TargetHandlerGetNotificationRequest {}
1118
1119#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1120pub struct TargetHandlerGetPlayerApplicationSettingsRequest {
1121 pub attribute_ids: Vec<PlayerApplicationSettingAttributeId>,
1122}
1123
1124impl fidl::Persistable for TargetHandlerGetPlayerApplicationSettingsRequest {}
1125
1126#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1127pub struct TargetHandlerSendCommandRequest {
1128 pub command: AvcPanelCommand,
1129 pub pressed: bool,
1130}
1131
1132impl fidl::Persistable for TargetHandlerSendCommandRequest {}
1133
1134#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1135#[repr(C)]
1136pub struct TargetHandlerSetAddressedPlayerRequest {
1137 pub player_id: AddressedPlayerId,
1138}
1139
1140impl fidl::Persistable for TargetHandlerSetAddressedPlayerRequest {}
1141
1142#[derive(Clone, Debug, PartialEq)]
1143pub struct TargetHandlerSetPlayerApplicationSettingsRequest {
1144 pub requested_settings: PlayerApplicationSettings,
1145}
1146
1147impl fidl::Persistable for TargetHandlerSetPlayerApplicationSettingsRequest {}
1148
1149#[derive(Clone, Debug, PartialEq)]
1150pub struct TargetHandlerWatchNotificationRequest {
1151 pub event_id: NotificationEvent,
1152 pub current: Notification,
1153 pub pos_change_interval: u32,
1154}
1155
1156impl fidl::Persistable for TargetHandlerWatchNotificationRequest {}
1157
1158#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1159pub struct TargetHandlerGetEventsSupportedResponse {
1160 pub notification_ids: Vec<NotificationEvent>,
1161}
1162
1163impl fidl::Persistable for TargetHandlerGetEventsSupportedResponse {}
1164
1165#[derive(Clone, Debug, PartialEq)]
1166pub struct TargetHandlerGetMediaAttributesResponse {
1167 pub attributes: MediaAttributes,
1168}
1169
1170impl fidl::Persistable for TargetHandlerGetMediaAttributesResponse {}
1171
1172#[derive(Clone, Debug, PartialEq)]
1173pub struct TargetHandlerGetMediaPlayerItemsResponse {
1174 pub items: Vec<MediaPlayerItem>,
1175}
1176
1177impl fidl::Persistable for TargetHandlerGetMediaPlayerItemsResponse {}
1178
1179#[derive(Clone, Debug, PartialEq)]
1180pub struct TargetHandlerGetNotificationResponse {
1181 pub current_value: Notification,
1182}
1183
1184impl fidl::Persistable for TargetHandlerGetNotificationResponse {}
1185
1186#[derive(Clone, Debug, PartialEq)]
1187pub struct TargetHandlerGetPlayStatusResponse {
1188 pub play_status: PlayStatus,
1189}
1190
1191impl fidl::Persistable for TargetHandlerGetPlayStatusResponse {}
1192
1193#[derive(Clone, Debug, PartialEq)]
1194pub struct TargetHandlerGetPlayerApplicationSettingsResponse {
1195 pub current_settings: PlayerApplicationSettings,
1196}
1197
1198impl fidl::Persistable for TargetHandlerGetPlayerApplicationSettingsResponse {}
1199
1200#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1201pub struct TargetHandlerListPlayerApplicationSettingAttributesResponse {
1202 pub attributes: Vec<PlayerApplicationSettingAttributeId>,
1203}
1204
1205impl fidl::Persistable for TargetHandlerListPlayerApplicationSettingAttributesResponse {}
1206
1207#[derive(Clone, Debug, PartialEq)]
1208pub struct TargetHandlerSetPlayerApplicationSettingsResponse {
1209 pub set_settings: PlayerApplicationSettings,
1210}
1211
1212impl fidl::Persistable for TargetHandlerSetPlayerApplicationSettingsResponse {}
1213
1214#[derive(Clone, Debug, PartialEq)]
1215pub struct TargetHandlerWatchNotificationResponse {
1216 pub new_value: Notification,
1217}
1218
1219impl fidl::Persistable for TargetHandlerWatchNotificationResponse {}
1220
1221#[derive(Clone, Debug, Default, PartialEq)]
1224pub struct CustomPlayerApplicationSetting {
1225 pub attribute_id: Option<u8>,
1228 pub attribute_name: Option<String>,
1230 pub possible_values: Option<Vec<CustomAttributeValue>>,
1232 pub current_value: Option<u8>,
1234 #[doc(hidden)]
1235 pub __source_breaking: fidl::marker::SourceBreaking,
1236}
1237
1238impl fidl::Persistable for CustomPlayerApplicationSetting {}
1239
1240#[derive(Clone, Debug, Default, PartialEq)]
1243pub struct FolderItem {
1244 pub folder_uid: Option<u64>,
1245 pub folder_type: Option<FolderType>,
1246 pub is_playable: Option<bool>,
1247 pub displayable_name: Option<String>,
1248 #[doc(hidden)]
1249 pub __source_breaking: fidl::marker::SourceBreaking,
1250}
1251
1252impl fidl::Persistable for FolderItem {}
1253
1254#[derive(Clone, Debug, Default, PartialEq)]
1256pub struct MediaAttributes {
1257 pub title: Option<String>,
1259 pub artist_name: Option<String>,
1261 pub album_name: Option<String>,
1263 pub track_number: Option<String>,
1265 pub total_number_of_tracks: Option<String>,
1267 pub genre: Option<String>,
1269 pub playing_time: Option<String>,
1271 #[doc(hidden)]
1272 pub __source_breaking: fidl::marker::SourceBreaking,
1273}
1274
1275impl fidl::Persistable for MediaAttributes {}
1276
1277#[derive(Clone, Debug, Default, PartialEq)]
1280pub struct MediaElementItem {
1281 pub media_element_uid: Option<u64>,
1282 pub media_type: Option<MediaType>,
1283 pub displayable_name: Option<String>,
1284 pub attributes: Option<MediaAttributes>,
1285 #[doc(hidden)]
1286 pub __source_breaking: fidl::marker::SourceBreaking,
1287}
1288
1289impl fidl::Persistable for MediaElementItem {}
1290
1291#[derive(Clone, Debug, Default, PartialEq)]
1294pub struct MediaPlayerItem {
1295 pub player_id: Option<u16>,
1296 pub major_type: Option<MajorPlayerType>,
1297 pub sub_type: Option<PlayerSubType>,
1298 pub playback_status: Option<PlaybackStatus>,
1299 pub displayable_name: Option<String>,
1300 pub feature_bits: Option<PlayerFeatureBits>,
1301 pub feature_bits_ext: Option<PlayerFeatureBitsExt>,
1302 #[doc(hidden)]
1303 pub __source_breaking: fidl::marker::SourceBreaking,
1304}
1305
1306impl fidl::Persistable for MediaPlayerItem {}
1307
1308#[derive(Clone, Debug, Default, PartialEq)]
1311pub struct Notification {
1312 pub status: Option<PlaybackStatus>,
1314 pub track_id: Option<u64>,
1316 pub pos: Option<u32>,
1318 pub battery_status: Option<BatteryStatus>,
1320 pub system_status: Option<SystemStatus>,
1322 pub application_settings: Option<PlayerApplicationSettings>,
1324 pub player_id: Option<u16>,
1326 pub volume: Option<u8>,
1328 pub device_connected: Option<bool>,
1330 pub available_players_changed: Option<bool>,
1332 pub addressed_player: Option<u16>,
1334 #[doc(hidden)]
1335 pub __source_breaking: fidl::marker::SourceBreaking,
1336}
1337
1338impl fidl::Persistable for Notification {}
1339
1340#[derive(Clone, Debug, Default, PartialEq)]
1343pub struct PlayStatus {
1344 pub song_length: Option<u32>,
1347 pub song_position: Option<u32>,
1350 pub playback_status: Option<PlaybackStatus>,
1353 #[doc(hidden)]
1354 pub __source_breaking: fidl::marker::SourceBreaking,
1355}
1356
1357impl fidl::Persistable for PlayStatus {}
1358
1359#[derive(Clone, Debug, Default, PartialEq)]
1361pub struct PlayerApplicationSettings {
1362 pub equalizer: Option<Equalizer>,
1364 pub repeat_status_mode: Option<RepeatStatusMode>,
1366 pub shuffle_mode: Option<ShuffleMode>,
1368 pub scan_mode: Option<ScanMode>,
1370 pub custom_settings: Option<Vec<CustomPlayerApplicationSetting>>,
1372 #[doc(hidden)]
1373 pub __source_breaking: fidl::marker::SourceBreaking,
1374}
1375
1376impl fidl::Persistable for PlayerApplicationSettings {}
1377
1378#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
1383pub enum AttributeRequestOption {
1384 GetAll(bool),
1385 AttributeList(Vec<MediaAttributeId>),
1386}
1387
1388impl AttributeRequestOption {
1389 #[inline]
1390 pub fn ordinal(&self) -> u64 {
1391 match *self {
1392 Self::GetAll(_) => 1,
1393 Self::AttributeList(_) => 2,
1394 }
1395 }
1396}
1397
1398impl fidl::Persistable for AttributeRequestOption {}
1399
1400#[derive(Clone, Debug, PartialEq)]
1404pub enum FileSystemItem {
1405 Folder(FolderItem),
1406 MediaElement(MediaElementItem),
1407}
1408
1409impl FileSystemItem {
1410 #[inline]
1411 pub fn ordinal(&self) -> u64 {
1412 match *self {
1413 Self::Folder(_) => 1,
1414 Self::MediaElement(_) => 2,
1415 }
1416 }
1417}
1418
1419impl fidl::Persistable for FileSystemItem {}
1420
1421#[derive(Clone, Debug)]
1426pub enum Path {
1427 Parent(Parent),
1428 ChildFolderUid(u64),
1429 #[doc(hidden)]
1430 __SourceBreaking {
1431 unknown_ordinal: u64,
1432 },
1433}
1434
1435#[macro_export]
1437macro_rules! PathUnknown {
1438 () => {
1439 _
1440 };
1441}
1442
1443impl PartialEq for Path {
1445 fn eq(&self, other: &Self) -> bool {
1446 match (self, other) {
1447 (Self::Parent(x), Self::Parent(y)) => *x == *y,
1448 (Self::ChildFolderUid(x), Self::ChildFolderUid(y)) => *x == *y,
1449 _ => false,
1450 }
1451 }
1452}
1453
1454impl Path {
1455 #[inline]
1456 pub fn ordinal(&self) -> u64 {
1457 match *self {
1458 Self::Parent(_) => 1,
1459 Self::ChildFolderUid(_) => 2,
1460 Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1461 }
1462 }
1463
1464 #[inline]
1465 pub fn unknown_variant_for_testing() -> Self {
1466 Self::__SourceBreaking { unknown_ordinal: 0 }
1467 }
1468
1469 #[inline]
1470 pub fn is_unknown(&self) -> bool {
1471 match self {
1472 Self::__SourceBreaking { .. } => true,
1473 _ => false,
1474 }
1475 }
1476}
1477
1478impl fidl::Persistable for Path {}
1479
1480mod internal {
1481 use super::*;
1482 unsafe impl fidl::encoding::TypeMarker for MajorPlayerType {
1483 type Owned = Self;
1484
1485 #[inline(always)]
1486 fn inline_align(_context: fidl::encoding::Context) -> usize {
1487 1
1488 }
1489
1490 #[inline(always)]
1491 fn inline_size(_context: fidl::encoding::Context) -> usize {
1492 1
1493 }
1494 }
1495
1496 impl fidl::encoding::ValueTypeMarker for MajorPlayerType {
1497 type Borrowed<'a> = Self;
1498 #[inline(always)]
1499 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1500 *value
1501 }
1502 }
1503
1504 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1505 for MajorPlayerType
1506 {
1507 #[inline]
1508 unsafe fn encode(
1509 self,
1510 encoder: &mut fidl::encoding::Encoder<'_, D>,
1511 offset: usize,
1512 _depth: fidl::encoding::Depth,
1513 ) -> fidl::Result<()> {
1514 encoder.debug_check_bounds::<Self>(offset);
1515 if self.bits() & Self::all().bits() != self.bits() {
1516 return Err(fidl::Error::InvalidBitsValue);
1517 }
1518 encoder.write_num(self.bits(), offset);
1519 Ok(())
1520 }
1521 }
1522
1523 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MajorPlayerType {
1524 #[inline(always)]
1525 fn new_empty() -> Self {
1526 Self::empty()
1527 }
1528
1529 #[inline]
1530 unsafe fn decode(
1531 &mut self,
1532 decoder: &mut fidl::encoding::Decoder<'_, D>,
1533 offset: usize,
1534 _depth: fidl::encoding::Depth,
1535 ) -> fidl::Result<()> {
1536 decoder.debug_check_bounds::<Self>(offset);
1537 let prim = decoder.read_num::<u8>(offset);
1538 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1539 Ok(())
1540 }
1541 }
1542 unsafe impl fidl::encoding::TypeMarker for Notifications {
1543 type Owned = Self;
1544
1545 #[inline(always)]
1546 fn inline_align(_context: fidl::encoding::Context) -> usize {
1547 4
1548 }
1549
1550 #[inline(always)]
1551 fn inline_size(_context: fidl::encoding::Context) -> usize {
1552 4
1553 }
1554 }
1555
1556 impl fidl::encoding::ValueTypeMarker for Notifications {
1557 type Borrowed<'a> = Self;
1558 #[inline(always)]
1559 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1560 *value
1561 }
1562 }
1563
1564 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Notifications {
1565 #[inline]
1566 unsafe fn encode(
1567 self,
1568 encoder: &mut fidl::encoding::Encoder<'_, D>,
1569 offset: usize,
1570 _depth: fidl::encoding::Depth,
1571 ) -> fidl::Result<()> {
1572 encoder.debug_check_bounds::<Self>(offset);
1573 if self.bits() & Self::all().bits() != self.bits() {
1574 return Err(fidl::Error::InvalidBitsValue);
1575 }
1576 encoder.write_num(self.bits(), offset);
1577 Ok(())
1578 }
1579 }
1580
1581 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notifications {
1582 #[inline(always)]
1583 fn new_empty() -> Self {
1584 Self::empty()
1585 }
1586
1587 #[inline]
1588 unsafe fn decode(
1589 &mut self,
1590 decoder: &mut fidl::encoding::Decoder<'_, D>,
1591 offset: usize,
1592 _depth: fidl::encoding::Depth,
1593 ) -> fidl::Result<()> {
1594 decoder.debug_check_bounds::<Self>(offset);
1595 let prim = decoder.read_num::<u32>(offset);
1596 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1597 Ok(())
1598 }
1599 }
1600 unsafe impl fidl::encoding::TypeMarker for PlayerFeatureBits {
1601 type Owned = Self;
1602
1603 #[inline(always)]
1604 fn inline_align(_context: fidl::encoding::Context) -> usize {
1605 8
1606 }
1607
1608 #[inline(always)]
1609 fn inline_size(_context: fidl::encoding::Context) -> usize {
1610 8
1611 }
1612 }
1613
1614 impl fidl::encoding::ValueTypeMarker for PlayerFeatureBits {
1615 type Borrowed<'a> = Self;
1616 #[inline(always)]
1617 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1618 *value
1619 }
1620 }
1621
1622 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1623 for PlayerFeatureBits
1624 {
1625 #[inline]
1626 unsafe fn encode(
1627 self,
1628 encoder: &mut fidl::encoding::Encoder<'_, D>,
1629 offset: usize,
1630 _depth: fidl::encoding::Depth,
1631 ) -> fidl::Result<()> {
1632 encoder.debug_check_bounds::<Self>(offset);
1633 if self.bits() & Self::all().bits() != self.bits() {
1634 return Err(fidl::Error::InvalidBitsValue);
1635 }
1636 encoder.write_num(self.bits(), offset);
1637 Ok(())
1638 }
1639 }
1640
1641 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerFeatureBits {
1642 #[inline(always)]
1643 fn new_empty() -> Self {
1644 Self::empty()
1645 }
1646
1647 #[inline]
1648 unsafe fn decode(
1649 &mut self,
1650 decoder: &mut fidl::encoding::Decoder<'_, D>,
1651 offset: usize,
1652 _depth: fidl::encoding::Depth,
1653 ) -> fidl::Result<()> {
1654 decoder.debug_check_bounds::<Self>(offset);
1655 let prim = decoder.read_num::<u64>(offset);
1656 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1657 Ok(())
1658 }
1659 }
1660 unsafe impl fidl::encoding::TypeMarker for PlayerFeatureBitsExt {
1661 type Owned = Self;
1662
1663 #[inline(always)]
1664 fn inline_align(_context: fidl::encoding::Context) -> usize {
1665 8
1666 }
1667
1668 #[inline(always)]
1669 fn inline_size(_context: fidl::encoding::Context) -> usize {
1670 8
1671 }
1672 }
1673
1674 impl fidl::encoding::ValueTypeMarker for PlayerFeatureBitsExt {
1675 type Borrowed<'a> = Self;
1676 #[inline(always)]
1677 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1678 *value
1679 }
1680 }
1681
1682 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1683 for PlayerFeatureBitsExt
1684 {
1685 #[inline]
1686 unsafe fn encode(
1687 self,
1688 encoder: &mut fidl::encoding::Encoder<'_, D>,
1689 offset: usize,
1690 _depth: fidl::encoding::Depth,
1691 ) -> fidl::Result<()> {
1692 encoder.debug_check_bounds::<Self>(offset);
1693 if self.bits() & Self::all().bits() != self.bits() {
1694 return Err(fidl::Error::InvalidBitsValue);
1695 }
1696 encoder.write_num(self.bits(), offset);
1697 Ok(())
1698 }
1699 }
1700
1701 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerFeatureBitsExt {
1702 #[inline(always)]
1703 fn new_empty() -> Self {
1704 Self::empty()
1705 }
1706
1707 #[inline]
1708 unsafe fn decode(
1709 &mut self,
1710 decoder: &mut fidl::encoding::Decoder<'_, D>,
1711 offset: usize,
1712 _depth: fidl::encoding::Depth,
1713 ) -> fidl::Result<()> {
1714 decoder.debug_check_bounds::<Self>(offset);
1715 let prim = decoder.read_num::<u64>(offset);
1716 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1717 Ok(())
1718 }
1719 }
1720 unsafe impl fidl::encoding::TypeMarker for PlayerSubType {
1721 type Owned = Self;
1722
1723 #[inline(always)]
1724 fn inline_align(_context: fidl::encoding::Context) -> usize {
1725 4
1726 }
1727
1728 #[inline(always)]
1729 fn inline_size(_context: fidl::encoding::Context) -> usize {
1730 4
1731 }
1732 }
1733
1734 impl fidl::encoding::ValueTypeMarker for PlayerSubType {
1735 type Borrowed<'a> = Self;
1736 #[inline(always)]
1737 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1738 *value
1739 }
1740 }
1741
1742 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlayerSubType {
1743 #[inline]
1744 unsafe fn encode(
1745 self,
1746 encoder: &mut fidl::encoding::Encoder<'_, D>,
1747 offset: usize,
1748 _depth: fidl::encoding::Depth,
1749 ) -> fidl::Result<()> {
1750 encoder.debug_check_bounds::<Self>(offset);
1751 if self.bits() & Self::all().bits() != self.bits() {
1752 return Err(fidl::Error::InvalidBitsValue);
1753 }
1754 encoder.write_num(self.bits(), offset);
1755 Ok(())
1756 }
1757 }
1758
1759 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayerSubType {
1760 #[inline(always)]
1761 fn new_empty() -> Self {
1762 Self::empty()
1763 }
1764
1765 #[inline]
1766 unsafe fn decode(
1767 &mut self,
1768 decoder: &mut fidl::encoding::Decoder<'_, D>,
1769 offset: usize,
1770 _depth: fidl::encoding::Depth,
1771 ) -> fidl::Result<()> {
1772 decoder.debug_check_bounds::<Self>(offset);
1773 let prim = decoder.read_num::<u32>(offset);
1774 *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1775 Ok(())
1776 }
1777 }
1778 unsafe impl fidl::encoding::TypeMarker for AvcPanelCommand {
1779 type Owned = Self;
1780
1781 #[inline(always)]
1782 fn inline_align(_context: fidl::encoding::Context) -> usize {
1783 std::mem::align_of::<u8>()
1784 }
1785
1786 #[inline(always)]
1787 fn inline_size(_context: fidl::encoding::Context) -> usize {
1788 std::mem::size_of::<u8>()
1789 }
1790
1791 #[inline(always)]
1792 fn encode_is_copy() -> bool {
1793 true
1794 }
1795
1796 #[inline(always)]
1797 fn decode_is_copy() -> bool {
1798 false
1799 }
1800 }
1801
1802 impl fidl::encoding::ValueTypeMarker for AvcPanelCommand {
1803 type Borrowed<'a> = Self;
1804 #[inline(always)]
1805 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1806 *value
1807 }
1808 }
1809
1810 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1811 for AvcPanelCommand
1812 {
1813 #[inline]
1814 unsafe fn encode(
1815 self,
1816 encoder: &mut fidl::encoding::Encoder<'_, D>,
1817 offset: usize,
1818 _depth: fidl::encoding::Depth,
1819 ) -> fidl::Result<()> {
1820 encoder.debug_check_bounds::<Self>(offset);
1821 encoder.write_num(self.into_primitive(), offset);
1822 Ok(())
1823 }
1824 }
1825
1826 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AvcPanelCommand {
1827 #[inline(always)]
1828 fn new_empty() -> Self {
1829 Self::Select
1830 }
1831
1832 #[inline]
1833 unsafe fn decode(
1834 &mut self,
1835 decoder: &mut fidl::encoding::Decoder<'_, D>,
1836 offset: usize,
1837 _depth: fidl::encoding::Depth,
1838 ) -> fidl::Result<()> {
1839 decoder.debug_check_bounds::<Self>(offset);
1840 let prim = decoder.read_num::<u8>(offset);
1841
1842 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1843 Ok(())
1844 }
1845 }
1846 unsafe impl fidl::encoding::TypeMarker for BatteryStatus {
1847 type Owned = Self;
1848
1849 #[inline(always)]
1850 fn inline_align(_context: fidl::encoding::Context) -> usize {
1851 std::mem::align_of::<u8>()
1852 }
1853
1854 #[inline(always)]
1855 fn inline_size(_context: fidl::encoding::Context) -> usize {
1856 std::mem::size_of::<u8>()
1857 }
1858
1859 #[inline(always)]
1860 fn encode_is_copy() -> bool {
1861 true
1862 }
1863
1864 #[inline(always)]
1865 fn decode_is_copy() -> bool {
1866 false
1867 }
1868 }
1869
1870 impl fidl::encoding::ValueTypeMarker for BatteryStatus {
1871 type Borrowed<'a> = Self;
1872 #[inline(always)]
1873 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1874 *value
1875 }
1876 }
1877
1878 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for BatteryStatus {
1879 #[inline]
1880 unsafe fn encode(
1881 self,
1882 encoder: &mut fidl::encoding::Encoder<'_, D>,
1883 offset: usize,
1884 _depth: fidl::encoding::Depth,
1885 ) -> fidl::Result<()> {
1886 encoder.debug_check_bounds::<Self>(offset);
1887 encoder.write_num(self.into_primitive(), offset);
1888 Ok(())
1889 }
1890 }
1891
1892 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BatteryStatus {
1893 #[inline(always)]
1894 fn new_empty() -> Self {
1895 Self::Normal
1896 }
1897
1898 #[inline]
1899 unsafe fn decode(
1900 &mut self,
1901 decoder: &mut fidl::encoding::Decoder<'_, D>,
1902 offset: usize,
1903 _depth: fidl::encoding::Depth,
1904 ) -> fidl::Result<()> {
1905 decoder.debug_check_bounds::<Self>(offset);
1906 let prim = decoder.read_num::<u8>(offset);
1907
1908 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1909 Ok(())
1910 }
1911 }
1912 unsafe impl fidl::encoding::TypeMarker for BrowseControllerError {
1913 type Owned = Self;
1914
1915 #[inline(always)]
1916 fn inline_align(_context: fidl::encoding::Context) -> usize {
1917 std::mem::align_of::<u32>()
1918 }
1919
1920 #[inline(always)]
1921 fn inline_size(_context: fidl::encoding::Context) -> usize {
1922 std::mem::size_of::<u32>()
1923 }
1924
1925 #[inline(always)]
1926 fn encode_is_copy() -> bool {
1927 true
1928 }
1929
1930 #[inline(always)]
1931 fn decode_is_copy() -> bool {
1932 false
1933 }
1934 }
1935
1936 impl fidl::encoding::ValueTypeMarker for BrowseControllerError {
1937 type Borrowed<'a> = Self;
1938 #[inline(always)]
1939 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1940 *value
1941 }
1942 }
1943
1944 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1945 for BrowseControllerError
1946 {
1947 #[inline]
1948 unsafe fn encode(
1949 self,
1950 encoder: &mut fidl::encoding::Encoder<'_, D>,
1951 offset: usize,
1952 _depth: fidl::encoding::Depth,
1953 ) -> fidl::Result<()> {
1954 encoder.debug_check_bounds::<Self>(offset);
1955 encoder.write_num(self.into_primitive(), offset);
1956 Ok(())
1957 }
1958 }
1959
1960 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BrowseControllerError {
1961 #[inline(always)]
1962 fn new_empty() -> Self {
1963 Self::UnknownFailure
1964 }
1965
1966 #[inline]
1967 unsafe fn decode(
1968 &mut self,
1969 decoder: &mut fidl::encoding::Decoder<'_, D>,
1970 offset: usize,
1971 _depth: fidl::encoding::Depth,
1972 ) -> fidl::Result<()> {
1973 decoder.debug_check_bounds::<Self>(offset);
1974 let prim = decoder.read_num::<u32>(offset);
1975
1976 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1977 Ok(())
1978 }
1979 }
1980 unsafe impl fidl::encoding::TypeMarker for ControllerError {
1981 type Owned = Self;
1982
1983 #[inline(always)]
1984 fn inline_align(_context: fidl::encoding::Context) -> usize {
1985 std::mem::align_of::<u32>()
1986 }
1987
1988 #[inline(always)]
1989 fn inline_size(_context: fidl::encoding::Context) -> usize {
1990 std::mem::size_of::<u32>()
1991 }
1992
1993 #[inline(always)]
1994 fn encode_is_copy() -> bool {
1995 true
1996 }
1997
1998 #[inline(always)]
1999 fn decode_is_copy() -> bool {
2000 false
2001 }
2002 }
2003
2004 impl fidl::encoding::ValueTypeMarker for ControllerError {
2005 type Borrowed<'a> = Self;
2006 #[inline(always)]
2007 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2008 *value
2009 }
2010 }
2011
2012 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2013 for ControllerError
2014 {
2015 #[inline]
2016 unsafe fn encode(
2017 self,
2018 encoder: &mut fidl::encoding::Encoder<'_, D>,
2019 offset: usize,
2020 _depth: fidl::encoding::Depth,
2021 ) -> fidl::Result<()> {
2022 encoder.debug_check_bounds::<Self>(offset);
2023 encoder.write_num(self.into_primitive(), offset);
2024 Ok(())
2025 }
2026 }
2027
2028 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControllerError {
2029 #[inline(always)]
2030 fn new_empty() -> Self {
2031 Self::UnknownFailure
2032 }
2033
2034 #[inline]
2035 unsafe fn decode(
2036 &mut self,
2037 decoder: &mut fidl::encoding::Decoder<'_, D>,
2038 offset: usize,
2039 _depth: fidl::encoding::Depth,
2040 ) -> fidl::Result<()> {
2041 decoder.debug_check_bounds::<Self>(offset);
2042 let prim = decoder.read_num::<u32>(offset);
2043
2044 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2045 Ok(())
2046 }
2047 }
2048 unsafe impl fidl::encoding::TypeMarker for Equalizer {
2049 type Owned = Self;
2050
2051 #[inline(always)]
2052 fn inline_align(_context: fidl::encoding::Context) -> usize {
2053 std::mem::align_of::<u8>()
2054 }
2055
2056 #[inline(always)]
2057 fn inline_size(_context: fidl::encoding::Context) -> usize {
2058 std::mem::size_of::<u8>()
2059 }
2060
2061 #[inline(always)]
2062 fn encode_is_copy() -> bool {
2063 true
2064 }
2065
2066 #[inline(always)]
2067 fn decode_is_copy() -> bool {
2068 false
2069 }
2070 }
2071
2072 impl fidl::encoding::ValueTypeMarker for Equalizer {
2073 type Borrowed<'a> = Self;
2074 #[inline(always)]
2075 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2076 *value
2077 }
2078 }
2079
2080 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Equalizer {
2081 #[inline]
2082 unsafe fn encode(
2083 self,
2084 encoder: &mut fidl::encoding::Encoder<'_, D>,
2085 offset: usize,
2086 _depth: fidl::encoding::Depth,
2087 ) -> fidl::Result<()> {
2088 encoder.debug_check_bounds::<Self>(offset);
2089 encoder.write_num(self.into_primitive(), offset);
2090 Ok(())
2091 }
2092 }
2093
2094 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Equalizer {
2095 #[inline(always)]
2096 fn new_empty() -> Self {
2097 Self::Off
2098 }
2099
2100 #[inline]
2101 unsafe fn decode(
2102 &mut self,
2103 decoder: &mut fidl::encoding::Decoder<'_, D>,
2104 offset: usize,
2105 _depth: fidl::encoding::Depth,
2106 ) -> fidl::Result<()> {
2107 decoder.debug_check_bounds::<Self>(offset);
2108 let prim = decoder.read_num::<u8>(offset);
2109
2110 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2111 Ok(())
2112 }
2113 }
2114 unsafe impl fidl::encoding::TypeMarker for FolderType {
2115 type Owned = Self;
2116
2117 #[inline(always)]
2118 fn inline_align(_context: fidl::encoding::Context) -> usize {
2119 std::mem::align_of::<u8>()
2120 }
2121
2122 #[inline(always)]
2123 fn inline_size(_context: fidl::encoding::Context) -> usize {
2124 std::mem::size_of::<u8>()
2125 }
2126
2127 #[inline(always)]
2128 fn encode_is_copy() -> bool {
2129 true
2130 }
2131
2132 #[inline(always)]
2133 fn decode_is_copy() -> bool {
2134 false
2135 }
2136 }
2137
2138 impl fidl::encoding::ValueTypeMarker for FolderType {
2139 type Borrowed<'a> = Self;
2140 #[inline(always)]
2141 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2142 *value
2143 }
2144 }
2145
2146 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FolderType {
2147 #[inline]
2148 unsafe fn encode(
2149 self,
2150 encoder: &mut fidl::encoding::Encoder<'_, D>,
2151 offset: usize,
2152 _depth: fidl::encoding::Depth,
2153 ) -> fidl::Result<()> {
2154 encoder.debug_check_bounds::<Self>(offset);
2155 encoder.write_num(self.into_primitive(), offset);
2156 Ok(())
2157 }
2158 }
2159
2160 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FolderType {
2161 #[inline(always)]
2162 fn new_empty() -> Self {
2163 Self::Mixed
2164 }
2165
2166 #[inline]
2167 unsafe fn decode(
2168 &mut self,
2169 decoder: &mut fidl::encoding::Decoder<'_, D>,
2170 offset: usize,
2171 _depth: fidl::encoding::Depth,
2172 ) -> fidl::Result<()> {
2173 decoder.debug_check_bounds::<Self>(offset);
2174 let prim = decoder.read_num::<u8>(offset);
2175
2176 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2177 Ok(())
2178 }
2179 }
2180 unsafe impl fidl::encoding::TypeMarker for MediaAttributeId {
2181 type Owned = Self;
2182
2183 #[inline(always)]
2184 fn inline_align(_context: fidl::encoding::Context) -> usize {
2185 std::mem::align_of::<u32>()
2186 }
2187
2188 #[inline(always)]
2189 fn inline_size(_context: fidl::encoding::Context) -> usize {
2190 std::mem::size_of::<u32>()
2191 }
2192
2193 #[inline(always)]
2194 fn encode_is_copy() -> bool {
2195 true
2196 }
2197
2198 #[inline(always)]
2199 fn decode_is_copy() -> bool {
2200 false
2201 }
2202 }
2203
2204 impl fidl::encoding::ValueTypeMarker for MediaAttributeId {
2205 type Borrowed<'a> = Self;
2206 #[inline(always)]
2207 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2208 *value
2209 }
2210 }
2211
2212 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2213 for MediaAttributeId
2214 {
2215 #[inline]
2216 unsafe fn encode(
2217 self,
2218 encoder: &mut fidl::encoding::Encoder<'_, D>,
2219 offset: usize,
2220 _depth: fidl::encoding::Depth,
2221 ) -> fidl::Result<()> {
2222 encoder.debug_check_bounds::<Self>(offset);
2223 encoder.write_num(self.into_primitive(), offset);
2224 Ok(())
2225 }
2226 }
2227
2228 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaAttributeId {
2229 #[inline(always)]
2230 fn new_empty() -> Self {
2231 Self::Title
2232 }
2233
2234 #[inline]
2235 unsafe fn decode(
2236 &mut self,
2237 decoder: &mut fidl::encoding::Decoder<'_, D>,
2238 offset: usize,
2239 _depth: fidl::encoding::Depth,
2240 ) -> fidl::Result<()> {
2241 decoder.debug_check_bounds::<Self>(offset);
2242 let prim = decoder.read_num::<u32>(offset);
2243
2244 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2245 Ok(())
2246 }
2247 }
2248 unsafe impl fidl::encoding::TypeMarker for MediaType {
2249 type Owned = Self;
2250
2251 #[inline(always)]
2252 fn inline_align(_context: fidl::encoding::Context) -> usize {
2253 std::mem::align_of::<u8>()
2254 }
2255
2256 #[inline(always)]
2257 fn inline_size(_context: fidl::encoding::Context) -> usize {
2258 std::mem::size_of::<u8>()
2259 }
2260
2261 #[inline(always)]
2262 fn encode_is_copy() -> bool {
2263 true
2264 }
2265
2266 #[inline(always)]
2267 fn decode_is_copy() -> bool {
2268 false
2269 }
2270 }
2271
2272 impl fidl::encoding::ValueTypeMarker for MediaType {
2273 type Borrowed<'a> = Self;
2274 #[inline(always)]
2275 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2276 *value
2277 }
2278 }
2279
2280 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MediaType {
2281 #[inline]
2282 unsafe fn encode(
2283 self,
2284 encoder: &mut fidl::encoding::Encoder<'_, D>,
2285 offset: usize,
2286 _depth: fidl::encoding::Depth,
2287 ) -> fidl::Result<()> {
2288 encoder.debug_check_bounds::<Self>(offset);
2289 encoder.write_num(self.into_primitive(), offset);
2290 Ok(())
2291 }
2292 }
2293
2294 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaType {
2295 #[inline(always)]
2296 fn new_empty() -> Self {
2297 Self::Audio
2298 }
2299
2300 #[inline]
2301 unsafe fn decode(
2302 &mut self,
2303 decoder: &mut fidl::encoding::Decoder<'_, D>,
2304 offset: usize,
2305 _depth: fidl::encoding::Depth,
2306 ) -> fidl::Result<()> {
2307 decoder.debug_check_bounds::<Self>(offset);
2308 let prim = decoder.read_num::<u8>(offset);
2309
2310 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2311 Ok(())
2312 }
2313 }
2314 unsafe impl fidl::encoding::TypeMarker for NotificationEvent {
2315 type Owned = Self;
2316
2317 #[inline(always)]
2318 fn inline_align(_context: fidl::encoding::Context) -> usize {
2319 std::mem::align_of::<u8>()
2320 }
2321
2322 #[inline(always)]
2323 fn inline_size(_context: fidl::encoding::Context) -> usize {
2324 std::mem::size_of::<u8>()
2325 }
2326
2327 #[inline(always)]
2328 fn encode_is_copy() -> bool {
2329 true
2330 }
2331
2332 #[inline(always)]
2333 fn decode_is_copy() -> bool {
2334 false
2335 }
2336 }
2337
2338 impl fidl::encoding::ValueTypeMarker for NotificationEvent {
2339 type Borrowed<'a> = Self;
2340 #[inline(always)]
2341 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2342 *value
2343 }
2344 }
2345
2346 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2347 for NotificationEvent
2348 {
2349 #[inline]
2350 unsafe fn encode(
2351 self,
2352 encoder: &mut fidl::encoding::Encoder<'_, D>,
2353 offset: usize,
2354 _depth: fidl::encoding::Depth,
2355 ) -> fidl::Result<()> {
2356 encoder.debug_check_bounds::<Self>(offset);
2357 encoder.write_num(self.into_primitive(), offset);
2358 Ok(())
2359 }
2360 }
2361
2362 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NotificationEvent {
2363 #[inline(always)]
2364 fn new_empty() -> Self {
2365 Self::PlaybackStatusChanged
2366 }
2367
2368 #[inline]
2369 unsafe fn decode(
2370 &mut self,
2371 decoder: &mut fidl::encoding::Decoder<'_, D>,
2372 offset: usize,
2373 _depth: fidl::encoding::Depth,
2374 ) -> fidl::Result<()> {
2375 decoder.debug_check_bounds::<Self>(offset);
2376 let prim = decoder.read_num::<u8>(offset);
2377
2378 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2379 Ok(())
2380 }
2381 }
2382 unsafe impl fidl::encoding::TypeMarker for PlaybackStatus {
2383 type Owned = Self;
2384
2385 #[inline(always)]
2386 fn inline_align(_context: fidl::encoding::Context) -> usize {
2387 std::mem::align_of::<u8>()
2388 }
2389
2390 #[inline(always)]
2391 fn inline_size(_context: fidl::encoding::Context) -> usize {
2392 std::mem::size_of::<u8>()
2393 }
2394
2395 #[inline(always)]
2396 fn encode_is_copy() -> bool {
2397 true
2398 }
2399
2400 #[inline(always)]
2401 fn decode_is_copy() -> bool {
2402 false
2403 }
2404 }
2405
2406 impl fidl::encoding::ValueTypeMarker for PlaybackStatus {
2407 type Borrowed<'a> = Self;
2408 #[inline(always)]
2409 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2410 *value
2411 }
2412 }
2413
2414 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlaybackStatus {
2415 #[inline]
2416 unsafe fn encode(
2417 self,
2418 encoder: &mut fidl::encoding::Encoder<'_, D>,
2419 offset: usize,
2420 _depth: fidl::encoding::Depth,
2421 ) -> fidl::Result<()> {
2422 encoder.debug_check_bounds::<Self>(offset);
2423 encoder.write_num(self.into_primitive(), offset);
2424 Ok(())
2425 }
2426 }
2427
2428 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlaybackStatus {
2429 #[inline(always)]
2430 fn new_empty() -> Self {
2431 Self::Stopped
2432 }
2433
2434 #[inline]
2435 unsafe fn decode(
2436 &mut self,
2437 decoder: &mut fidl::encoding::Decoder<'_, D>,
2438 offset: usize,
2439 _depth: fidl::encoding::Depth,
2440 ) -> fidl::Result<()> {
2441 decoder.debug_check_bounds::<Self>(offset);
2442 let prim = decoder.read_num::<u8>(offset);
2443
2444 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2445 Ok(())
2446 }
2447 }
2448 unsafe impl fidl::encoding::TypeMarker for PlayerApplicationSettingAttributeId {
2449 type Owned = Self;
2450
2451 #[inline(always)]
2452 fn inline_align(_context: fidl::encoding::Context) -> usize {
2453 std::mem::align_of::<u8>()
2454 }
2455
2456 #[inline(always)]
2457 fn inline_size(_context: fidl::encoding::Context) -> usize {
2458 std::mem::size_of::<u8>()
2459 }
2460
2461 #[inline(always)]
2462 fn encode_is_copy() -> bool {
2463 true
2464 }
2465
2466 #[inline(always)]
2467 fn decode_is_copy() -> bool {
2468 false
2469 }
2470 }
2471
2472 impl fidl::encoding::ValueTypeMarker for PlayerApplicationSettingAttributeId {
2473 type Borrowed<'a> = Self;
2474 #[inline(always)]
2475 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476 *value
2477 }
2478 }
2479
2480 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2481 for PlayerApplicationSettingAttributeId
2482 {
2483 #[inline]
2484 unsafe fn encode(
2485 self,
2486 encoder: &mut fidl::encoding::Encoder<'_, D>,
2487 offset: usize,
2488 _depth: fidl::encoding::Depth,
2489 ) -> fidl::Result<()> {
2490 encoder.debug_check_bounds::<Self>(offset);
2491 encoder.write_num(self.into_primitive(), offset);
2492 Ok(())
2493 }
2494 }
2495
2496 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2497 for PlayerApplicationSettingAttributeId
2498 {
2499 #[inline(always)]
2500 fn new_empty() -> Self {
2501 Self::Equalizer
2502 }
2503
2504 #[inline]
2505 unsafe fn decode(
2506 &mut self,
2507 decoder: &mut fidl::encoding::Decoder<'_, D>,
2508 offset: usize,
2509 _depth: fidl::encoding::Depth,
2510 ) -> fidl::Result<()> {
2511 decoder.debug_check_bounds::<Self>(offset);
2512 let prim = decoder.read_num::<u8>(offset);
2513
2514 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2515 Ok(())
2516 }
2517 }
2518 unsafe impl fidl::encoding::TypeMarker for RepeatStatusMode {
2519 type Owned = Self;
2520
2521 #[inline(always)]
2522 fn inline_align(_context: fidl::encoding::Context) -> usize {
2523 std::mem::align_of::<u8>()
2524 }
2525
2526 #[inline(always)]
2527 fn inline_size(_context: fidl::encoding::Context) -> usize {
2528 std::mem::size_of::<u8>()
2529 }
2530
2531 #[inline(always)]
2532 fn encode_is_copy() -> bool {
2533 true
2534 }
2535
2536 #[inline(always)]
2537 fn decode_is_copy() -> bool {
2538 false
2539 }
2540 }
2541
2542 impl fidl::encoding::ValueTypeMarker for RepeatStatusMode {
2543 type Borrowed<'a> = Self;
2544 #[inline(always)]
2545 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2546 *value
2547 }
2548 }
2549
2550 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2551 for RepeatStatusMode
2552 {
2553 #[inline]
2554 unsafe fn encode(
2555 self,
2556 encoder: &mut fidl::encoding::Encoder<'_, D>,
2557 offset: usize,
2558 _depth: fidl::encoding::Depth,
2559 ) -> fidl::Result<()> {
2560 encoder.debug_check_bounds::<Self>(offset);
2561 encoder.write_num(self.into_primitive(), offset);
2562 Ok(())
2563 }
2564 }
2565
2566 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepeatStatusMode {
2567 #[inline(always)]
2568 fn new_empty() -> Self {
2569 Self::Off
2570 }
2571
2572 #[inline]
2573 unsafe fn decode(
2574 &mut self,
2575 decoder: &mut fidl::encoding::Decoder<'_, D>,
2576 offset: usize,
2577 _depth: fidl::encoding::Depth,
2578 ) -> fidl::Result<()> {
2579 decoder.debug_check_bounds::<Self>(offset);
2580 let prim = decoder.read_num::<u8>(offset);
2581
2582 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2583 Ok(())
2584 }
2585 }
2586 unsafe impl fidl::encoding::TypeMarker for ScanMode {
2587 type Owned = Self;
2588
2589 #[inline(always)]
2590 fn inline_align(_context: fidl::encoding::Context) -> usize {
2591 std::mem::align_of::<u8>()
2592 }
2593
2594 #[inline(always)]
2595 fn inline_size(_context: fidl::encoding::Context) -> usize {
2596 std::mem::size_of::<u8>()
2597 }
2598
2599 #[inline(always)]
2600 fn encode_is_copy() -> bool {
2601 true
2602 }
2603
2604 #[inline(always)]
2605 fn decode_is_copy() -> bool {
2606 false
2607 }
2608 }
2609
2610 impl fidl::encoding::ValueTypeMarker for ScanMode {
2611 type Borrowed<'a> = Self;
2612 #[inline(always)]
2613 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2614 *value
2615 }
2616 }
2617
2618 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ScanMode {
2619 #[inline]
2620 unsafe fn encode(
2621 self,
2622 encoder: &mut fidl::encoding::Encoder<'_, D>,
2623 offset: usize,
2624 _depth: fidl::encoding::Depth,
2625 ) -> fidl::Result<()> {
2626 encoder.debug_check_bounds::<Self>(offset);
2627 encoder.write_num(self.into_primitive(), offset);
2628 Ok(())
2629 }
2630 }
2631
2632 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanMode {
2633 #[inline(always)]
2634 fn new_empty() -> Self {
2635 Self::Off
2636 }
2637
2638 #[inline]
2639 unsafe fn decode(
2640 &mut self,
2641 decoder: &mut fidl::encoding::Decoder<'_, D>,
2642 offset: usize,
2643 _depth: fidl::encoding::Depth,
2644 ) -> fidl::Result<()> {
2645 decoder.debug_check_bounds::<Self>(offset);
2646 let prim = decoder.read_num::<u8>(offset);
2647
2648 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2649 Ok(())
2650 }
2651 }
2652 unsafe impl fidl::encoding::TypeMarker for ShuffleMode {
2653 type Owned = Self;
2654
2655 #[inline(always)]
2656 fn inline_align(_context: fidl::encoding::Context) -> usize {
2657 std::mem::align_of::<u8>()
2658 }
2659
2660 #[inline(always)]
2661 fn inline_size(_context: fidl::encoding::Context) -> usize {
2662 std::mem::size_of::<u8>()
2663 }
2664
2665 #[inline(always)]
2666 fn encode_is_copy() -> bool {
2667 true
2668 }
2669
2670 #[inline(always)]
2671 fn decode_is_copy() -> bool {
2672 false
2673 }
2674 }
2675
2676 impl fidl::encoding::ValueTypeMarker for ShuffleMode {
2677 type Borrowed<'a> = Self;
2678 #[inline(always)]
2679 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2680 *value
2681 }
2682 }
2683
2684 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ShuffleMode {
2685 #[inline]
2686 unsafe fn encode(
2687 self,
2688 encoder: &mut fidl::encoding::Encoder<'_, D>,
2689 offset: usize,
2690 _depth: fidl::encoding::Depth,
2691 ) -> fidl::Result<()> {
2692 encoder.debug_check_bounds::<Self>(offset);
2693 encoder.write_num(self.into_primitive(), offset);
2694 Ok(())
2695 }
2696 }
2697
2698 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ShuffleMode {
2699 #[inline(always)]
2700 fn new_empty() -> Self {
2701 Self::Off
2702 }
2703
2704 #[inline]
2705 unsafe fn decode(
2706 &mut self,
2707 decoder: &mut fidl::encoding::Decoder<'_, D>,
2708 offset: usize,
2709 _depth: fidl::encoding::Depth,
2710 ) -> fidl::Result<()> {
2711 decoder.debug_check_bounds::<Self>(offset);
2712 let prim = decoder.read_num::<u8>(offset);
2713
2714 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2715 Ok(())
2716 }
2717 }
2718 unsafe impl fidl::encoding::TypeMarker for SystemStatus {
2719 type Owned = Self;
2720
2721 #[inline(always)]
2722 fn inline_align(_context: fidl::encoding::Context) -> usize {
2723 std::mem::align_of::<u8>()
2724 }
2725
2726 #[inline(always)]
2727 fn inline_size(_context: fidl::encoding::Context) -> usize {
2728 std::mem::size_of::<u8>()
2729 }
2730
2731 #[inline(always)]
2732 fn encode_is_copy() -> bool {
2733 true
2734 }
2735
2736 #[inline(always)]
2737 fn decode_is_copy() -> bool {
2738 false
2739 }
2740 }
2741
2742 impl fidl::encoding::ValueTypeMarker for SystemStatus {
2743 type Borrowed<'a> = Self;
2744 #[inline(always)]
2745 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2746 *value
2747 }
2748 }
2749
2750 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SystemStatus {
2751 #[inline]
2752 unsafe fn encode(
2753 self,
2754 encoder: &mut fidl::encoding::Encoder<'_, D>,
2755 offset: usize,
2756 _depth: fidl::encoding::Depth,
2757 ) -> fidl::Result<()> {
2758 encoder.debug_check_bounds::<Self>(offset);
2759 encoder.write_num(self.into_primitive(), offset);
2760 Ok(())
2761 }
2762 }
2763
2764 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SystemStatus {
2765 #[inline(always)]
2766 fn new_empty() -> Self {
2767 Self::PowerOn
2768 }
2769
2770 #[inline]
2771 unsafe fn decode(
2772 &mut self,
2773 decoder: &mut fidl::encoding::Decoder<'_, D>,
2774 offset: usize,
2775 _depth: fidl::encoding::Depth,
2776 ) -> fidl::Result<()> {
2777 decoder.debug_check_bounds::<Self>(offset);
2778 let prim = decoder.read_num::<u8>(offset);
2779
2780 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2781 Ok(())
2782 }
2783 }
2784 unsafe impl fidl::encoding::TypeMarker for TargetAvcError {
2785 type Owned = Self;
2786
2787 #[inline(always)]
2788 fn inline_align(_context: fidl::encoding::Context) -> usize {
2789 std::mem::align_of::<u32>()
2790 }
2791
2792 #[inline(always)]
2793 fn inline_size(_context: fidl::encoding::Context) -> usize {
2794 std::mem::size_of::<u32>()
2795 }
2796
2797 #[inline(always)]
2798 fn encode_is_copy() -> bool {
2799 true
2800 }
2801
2802 #[inline(always)]
2803 fn decode_is_copy() -> bool {
2804 false
2805 }
2806 }
2807
2808 impl fidl::encoding::ValueTypeMarker for TargetAvcError {
2809 type Borrowed<'a> = Self;
2810 #[inline(always)]
2811 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2812 *value
2813 }
2814 }
2815
2816 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for TargetAvcError {
2817 #[inline]
2818 unsafe fn encode(
2819 self,
2820 encoder: &mut fidl::encoding::Encoder<'_, D>,
2821 offset: usize,
2822 _depth: fidl::encoding::Depth,
2823 ) -> fidl::Result<()> {
2824 encoder.debug_check_bounds::<Self>(offset);
2825 encoder.write_num(self.into_primitive(), offset);
2826 Ok(())
2827 }
2828 }
2829
2830 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TargetAvcError {
2831 #[inline(always)]
2832 fn new_empty() -> Self {
2833 Self::RejectedInvalidCommand
2834 }
2835
2836 #[inline]
2837 unsafe fn decode(
2838 &mut self,
2839 decoder: &mut fidl::encoding::Decoder<'_, D>,
2840 offset: usize,
2841 _depth: fidl::encoding::Depth,
2842 ) -> fidl::Result<()> {
2843 decoder.debug_check_bounds::<Self>(offset);
2844 let prim = decoder.read_num::<u32>(offset);
2845
2846 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2847 Ok(())
2848 }
2849 }
2850 unsafe impl fidl::encoding::TypeMarker for TargetPassthroughError {
2851 type Owned = Self;
2852
2853 #[inline(always)]
2854 fn inline_align(_context: fidl::encoding::Context) -> usize {
2855 std::mem::align_of::<u32>()
2856 }
2857
2858 #[inline(always)]
2859 fn inline_size(_context: fidl::encoding::Context) -> usize {
2860 std::mem::size_of::<u32>()
2861 }
2862
2863 #[inline(always)]
2864 fn encode_is_copy() -> bool {
2865 true
2866 }
2867
2868 #[inline(always)]
2869 fn decode_is_copy() -> bool {
2870 false
2871 }
2872 }
2873
2874 impl fidl::encoding::ValueTypeMarker for TargetPassthroughError {
2875 type Borrowed<'a> = Self;
2876 #[inline(always)]
2877 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2878 *value
2879 }
2880 }
2881
2882 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2883 for TargetPassthroughError
2884 {
2885 #[inline]
2886 unsafe fn encode(
2887 self,
2888 encoder: &mut fidl::encoding::Encoder<'_, D>,
2889 offset: usize,
2890 _depth: fidl::encoding::Depth,
2891 ) -> fidl::Result<()> {
2892 encoder.debug_check_bounds::<Self>(offset);
2893 encoder.write_num(self.into_primitive(), offset);
2894 Ok(())
2895 }
2896 }
2897
2898 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2899 for TargetPassthroughError
2900 {
2901 #[inline(always)]
2902 fn new_empty() -> Self {
2903 Self::CommandNotImplemented
2904 }
2905
2906 #[inline]
2907 unsafe fn decode(
2908 &mut self,
2909 decoder: &mut fidl::encoding::Decoder<'_, D>,
2910 offset: usize,
2911 _depth: fidl::encoding::Depth,
2912 ) -> fidl::Result<()> {
2913 decoder.debug_check_bounds::<Self>(offset);
2914 let prim = decoder.read_num::<u32>(offset);
2915
2916 *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
2917 Ok(())
2918 }
2919 }
2920
2921 impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerGetCurrentVolumeResponse {
2922 type Borrowed<'a> = &'a Self;
2923 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2924 value
2925 }
2926 }
2927
2928 unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerGetCurrentVolumeResponse {
2929 type Owned = Self;
2930
2931 #[inline(always)]
2932 fn inline_align(_context: fidl::encoding::Context) -> usize {
2933 1
2934 }
2935
2936 #[inline(always)]
2937 fn inline_size(_context: fidl::encoding::Context) -> usize {
2938 1
2939 }
2940 #[inline(always)]
2941 fn encode_is_copy() -> bool {
2942 true
2943 }
2944
2945 #[inline(always)]
2946 fn decode_is_copy() -> bool {
2947 true
2948 }
2949 }
2950
2951 unsafe impl<D: fidl::encoding::ResourceDialect>
2952 fidl::encoding::Encode<AbsoluteVolumeHandlerGetCurrentVolumeResponse, D>
2953 for &AbsoluteVolumeHandlerGetCurrentVolumeResponse
2954 {
2955 #[inline]
2956 unsafe fn encode(
2957 self,
2958 encoder: &mut fidl::encoding::Encoder<'_, D>,
2959 offset: usize,
2960 _depth: fidl::encoding::Depth,
2961 ) -> fidl::Result<()> {
2962 encoder.debug_check_bounds::<AbsoluteVolumeHandlerGetCurrentVolumeResponse>(offset);
2963 unsafe {
2964 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2966 (buf_ptr as *mut AbsoluteVolumeHandlerGetCurrentVolumeResponse).write_unaligned(
2967 (self as *const AbsoluteVolumeHandlerGetCurrentVolumeResponse).read(),
2968 );
2969 }
2972 Ok(())
2973 }
2974 }
2975 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
2976 fidl::encoding::Encode<AbsoluteVolumeHandlerGetCurrentVolumeResponse, D> for (T0,)
2977 {
2978 #[inline]
2979 unsafe fn encode(
2980 self,
2981 encoder: &mut fidl::encoding::Encoder<'_, D>,
2982 offset: usize,
2983 depth: fidl::encoding::Depth,
2984 ) -> fidl::Result<()> {
2985 encoder.debug_check_bounds::<AbsoluteVolumeHandlerGetCurrentVolumeResponse>(offset);
2986 self.0.encode(encoder, offset + 0, depth)?;
2990 Ok(())
2991 }
2992 }
2993
2994 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2995 for AbsoluteVolumeHandlerGetCurrentVolumeResponse
2996 {
2997 #[inline(always)]
2998 fn new_empty() -> Self {
2999 Self { volume: fidl::new_empty!(u8, D) }
3000 }
3001
3002 #[inline]
3003 unsafe fn decode(
3004 &mut self,
3005 decoder: &mut fidl::encoding::Decoder<'_, D>,
3006 offset: usize,
3007 _depth: fidl::encoding::Depth,
3008 ) -> fidl::Result<()> {
3009 decoder.debug_check_bounds::<Self>(offset);
3010 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3011 unsafe {
3014 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3015 }
3016 Ok(())
3017 }
3018 }
3019
3020 impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerOnVolumeChangedResponse {
3021 type Borrowed<'a> = &'a Self;
3022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3023 value
3024 }
3025 }
3026
3027 unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerOnVolumeChangedResponse {
3028 type Owned = Self;
3029
3030 #[inline(always)]
3031 fn inline_align(_context: fidl::encoding::Context) -> usize {
3032 1
3033 }
3034
3035 #[inline(always)]
3036 fn inline_size(_context: fidl::encoding::Context) -> usize {
3037 1
3038 }
3039 #[inline(always)]
3040 fn encode_is_copy() -> bool {
3041 true
3042 }
3043
3044 #[inline(always)]
3045 fn decode_is_copy() -> bool {
3046 true
3047 }
3048 }
3049
3050 unsafe impl<D: fidl::encoding::ResourceDialect>
3051 fidl::encoding::Encode<AbsoluteVolumeHandlerOnVolumeChangedResponse, D>
3052 for &AbsoluteVolumeHandlerOnVolumeChangedResponse
3053 {
3054 #[inline]
3055 unsafe fn encode(
3056 self,
3057 encoder: &mut fidl::encoding::Encoder<'_, D>,
3058 offset: usize,
3059 _depth: fidl::encoding::Depth,
3060 ) -> fidl::Result<()> {
3061 encoder.debug_check_bounds::<AbsoluteVolumeHandlerOnVolumeChangedResponse>(offset);
3062 unsafe {
3063 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3065 (buf_ptr as *mut AbsoluteVolumeHandlerOnVolumeChangedResponse).write_unaligned(
3066 (self as *const AbsoluteVolumeHandlerOnVolumeChangedResponse).read(),
3067 );
3068 }
3071 Ok(())
3072 }
3073 }
3074 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3075 fidl::encoding::Encode<AbsoluteVolumeHandlerOnVolumeChangedResponse, D> for (T0,)
3076 {
3077 #[inline]
3078 unsafe fn encode(
3079 self,
3080 encoder: &mut fidl::encoding::Encoder<'_, D>,
3081 offset: usize,
3082 depth: fidl::encoding::Depth,
3083 ) -> fidl::Result<()> {
3084 encoder.debug_check_bounds::<AbsoluteVolumeHandlerOnVolumeChangedResponse>(offset);
3085 self.0.encode(encoder, offset + 0, depth)?;
3089 Ok(())
3090 }
3091 }
3092
3093 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3094 for AbsoluteVolumeHandlerOnVolumeChangedResponse
3095 {
3096 #[inline(always)]
3097 fn new_empty() -> Self {
3098 Self { new_volume: fidl::new_empty!(u8, D) }
3099 }
3100
3101 #[inline]
3102 unsafe fn decode(
3103 &mut self,
3104 decoder: &mut fidl::encoding::Decoder<'_, D>,
3105 offset: usize,
3106 _depth: fidl::encoding::Depth,
3107 ) -> fidl::Result<()> {
3108 decoder.debug_check_bounds::<Self>(offset);
3109 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3110 unsafe {
3113 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3114 }
3115 Ok(())
3116 }
3117 }
3118
3119 impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerSetVolumeRequest {
3120 type Borrowed<'a> = &'a Self;
3121 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3122 value
3123 }
3124 }
3125
3126 unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerSetVolumeRequest {
3127 type Owned = Self;
3128
3129 #[inline(always)]
3130 fn inline_align(_context: fidl::encoding::Context) -> usize {
3131 1
3132 }
3133
3134 #[inline(always)]
3135 fn inline_size(_context: fidl::encoding::Context) -> usize {
3136 1
3137 }
3138 #[inline(always)]
3139 fn encode_is_copy() -> bool {
3140 true
3141 }
3142
3143 #[inline(always)]
3144 fn decode_is_copy() -> bool {
3145 true
3146 }
3147 }
3148
3149 unsafe impl<D: fidl::encoding::ResourceDialect>
3150 fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeRequest, D>
3151 for &AbsoluteVolumeHandlerSetVolumeRequest
3152 {
3153 #[inline]
3154 unsafe fn encode(
3155 self,
3156 encoder: &mut fidl::encoding::Encoder<'_, D>,
3157 offset: usize,
3158 _depth: fidl::encoding::Depth,
3159 ) -> fidl::Result<()> {
3160 encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeRequest>(offset);
3161 unsafe {
3162 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3164 (buf_ptr as *mut AbsoluteVolumeHandlerSetVolumeRequest)
3165 .write_unaligned((self as *const AbsoluteVolumeHandlerSetVolumeRequest).read());
3166 }
3169 Ok(())
3170 }
3171 }
3172 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3173 fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeRequest, D> for (T0,)
3174 {
3175 #[inline]
3176 unsafe fn encode(
3177 self,
3178 encoder: &mut fidl::encoding::Encoder<'_, D>,
3179 offset: usize,
3180 depth: fidl::encoding::Depth,
3181 ) -> fidl::Result<()> {
3182 encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeRequest>(offset);
3183 self.0.encode(encoder, offset + 0, depth)?;
3187 Ok(())
3188 }
3189 }
3190
3191 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3192 for AbsoluteVolumeHandlerSetVolumeRequest
3193 {
3194 #[inline(always)]
3195 fn new_empty() -> Self {
3196 Self { requested_volume: fidl::new_empty!(u8, D) }
3197 }
3198
3199 #[inline]
3200 unsafe fn decode(
3201 &mut self,
3202 decoder: &mut fidl::encoding::Decoder<'_, D>,
3203 offset: usize,
3204 _depth: fidl::encoding::Depth,
3205 ) -> fidl::Result<()> {
3206 decoder.debug_check_bounds::<Self>(offset);
3207 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3208 unsafe {
3211 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3212 }
3213 Ok(())
3214 }
3215 }
3216
3217 impl fidl::encoding::ValueTypeMarker for AbsoluteVolumeHandlerSetVolumeResponse {
3218 type Borrowed<'a> = &'a Self;
3219 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3220 value
3221 }
3222 }
3223
3224 unsafe impl fidl::encoding::TypeMarker for AbsoluteVolumeHandlerSetVolumeResponse {
3225 type Owned = Self;
3226
3227 #[inline(always)]
3228 fn inline_align(_context: fidl::encoding::Context) -> usize {
3229 1
3230 }
3231
3232 #[inline(always)]
3233 fn inline_size(_context: fidl::encoding::Context) -> usize {
3234 1
3235 }
3236 #[inline(always)]
3237 fn encode_is_copy() -> bool {
3238 true
3239 }
3240
3241 #[inline(always)]
3242 fn decode_is_copy() -> bool {
3243 true
3244 }
3245 }
3246
3247 unsafe impl<D: fidl::encoding::ResourceDialect>
3248 fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeResponse, D>
3249 for &AbsoluteVolumeHandlerSetVolumeResponse
3250 {
3251 #[inline]
3252 unsafe fn encode(
3253 self,
3254 encoder: &mut fidl::encoding::Encoder<'_, D>,
3255 offset: usize,
3256 _depth: fidl::encoding::Depth,
3257 ) -> fidl::Result<()> {
3258 encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeResponse>(offset);
3259 unsafe {
3260 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3262 (buf_ptr as *mut AbsoluteVolumeHandlerSetVolumeResponse).write_unaligned(
3263 (self as *const AbsoluteVolumeHandlerSetVolumeResponse).read(),
3264 );
3265 }
3268 Ok(())
3269 }
3270 }
3271 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
3272 fidl::encoding::Encode<AbsoluteVolumeHandlerSetVolumeResponse, D> for (T0,)
3273 {
3274 #[inline]
3275 unsafe fn encode(
3276 self,
3277 encoder: &mut fidl::encoding::Encoder<'_, D>,
3278 offset: usize,
3279 depth: fidl::encoding::Depth,
3280 ) -> fidl::Result<()> {
3281 encoder.debug_check_bounds::<AbsoluteVolumeHandlerSetVolumeResponse>(offset);
3282 self.0.encode(encoder, offset + 0, depth)?;
3286 Ok(())
3287 }
3288 }
3289
3290 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3291 for AbsoluteVolumeHandlerSetVolumeResponse
3292 {
3293 #[inline(always)]
3294 fn new_empty() -> Self {
3295 Self { set_volume: fidl::new_empty!(u8, D) }
3296 }
3297
3298 #[inline]
3299 unsafe fn decode(
3300 &mut self,
3301 decoder: &mut fidl::encoding::Decoder<'_, D>,
3302 offset: usize,
3303 _depth: fidl::encoding::Depth,
3304 ) -> fidl::Result<()> {
3305 decoder.debug_check_bounds::<Self>(offset);
3306 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3307 unsafe {
3310 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
3311 }
3312 Ok(())
3313 }
3314 }
3315
3316 impl fidl::encoding::ValueTypeMarker for AddressedPlayerId {
3317 type Borrowed<'a> = &'a Self;
3318 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3319 value
3320 }
3321 }
3322
3323 unsafe impl fidl::encoding::TypeMarker for AddressedPlayerId {
3324 type Owned = Self;
3325
3326 #[inline(always)]
3327 fn inline_align(_context: fidl::encoding::Context) -> usize {
3328 2
3329 }
3330
3331 #[inline(always)]
3332 fn inline_size(_context: fidl::encoding::Context) -> usize {
3333 2
3334 }
3335 #[inline(always)]
3336 fn encode_is_copy() -> bool {
3337 true
3338 }
3339
3340 #[inline(always)]
3341 fn decode_is_copy() -> bool {
3342 true
3343 }
3344 }
3345
3346 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressedPlayerId, D>
3347 for &AddressedPlayerId
3348 {
3349 #[inline]
3350 unsafe fn encode(
3351 self,
3352 encoder: &mut fidl::encoding::Encoder<'_, D>,
3353 offset: usize,
3354 _depth: fidl::encoding::Depth,
3355 ) -> fidl::Result<()> {
3356 encoder.debug_check_bounds::<AddressedPlayerId>(offset);
3357 unsafe {
3358 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3360 (buf_ptr as *mut AddressedPlayerId)
3361 .write_unaligned((self as *const AddressedPlayerId).read());
3362 }
3365 Ok(())
3366 }
3367 }
3368 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
3369 fidl::encoding::Encode<AddressedPlayerId, D> for (T0,)
3370 {
3371 #[inline]
3372 unsafe fn encode(
3373 self,
3374 encoder: &mut fidl::encoding::Encoder<'_, D>,
3375 offset: usize,
3376 depth: fidl::encoding::Depth,
3377 ) -> fidl::Result<()> {
3378 encoder.debug_check_bounds::<AddressedPlayerId>(offset);
3379 self.0.encode(encoder, offset + 0, depth)?;
3383 Ok(())
3384 }
3385 }
3386
3387 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressedPlayerId {
3388 #[inline(always)]
3389 fn new_empty() -> Self {
3390 Self { id: fidl::new_empty!(u16, D) }
3391 }
3392
3393 #[inline]
3394 unsafe fn decode(
3395 &mut self,
3396 decoder: &mut fidl::encoding::Decoder<'_, D>,
3397 offset: usize,
3398 _depth: fidl::encoding::Depth,
3399 ) -> fidl::Result<()> {
3400 decoder.debug_check_bounds::<Self>(offset);
3401 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3402 unsafe {
3405 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
3406 }
3407 Ok(())
3408 }
3409 }
3410
3411 impl fidl::encoding::ValueTypeMarker for BrowseControllerChangePathRequest {
3412 type Borrowed<'a> = &'a Self;
3413 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3414 value
3415 }
3416 }
3417
3418 unsafe impl fidl::encoding::TypeMarker for BrowseControllerChangePathRequest {
3419 type Owned = Self;
3420
3421 #[inline(always)]
3422 fn inline_align(_context: fidl::encoding::Context) -> usize {
3423 8
3424 }
3425
3426 #[inline(always)]
3427 fn inline_size(_context: fidl::encoding::Context) -> usize {
3428 16
3429 }
3430 }
3431
3432 unsafe impl<D: fidl::encoding::ResourceDialect>
3433 fidl::encoding::Encode<BrowseControllerChangePathRequest, D>
3434 for &BrowseControllerChangePathRequest
3435 {
3436 #[inline]
3437 unsafe fn encode(
3438 self,
3439 encoder: &mut fidl::encoding::Encoder<'_, D>,
3440 offset: usize,
3441 _depth: fidl::encoding::Depth,
3442 ) -> fidl::Result<()> {
3443 encoder.debug_check_bounds::<BrowseControllerChangePathRequest>(offset);
3444 fidl::encoding::Encode::<BrowseControllerChangePathRequest, D>::encode(
3446 (<Path as fidl::encoding::ValueTypeMarker>::borrow(&self.path),),
3447 encoder,
3448 offset,
3449 _depth,
3450 )
3451 }
3452 }
3453 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Path, D>>
3454 fidl::encoding::Encode<BrowseControllerChangePathRequest, D> for (T0,)
3455 {
3456 #[inline]
3457 unsafe fn encode(
3458 self,
3459 encoder: &mut fidl::encoding::Encoder<'_, D>,
3460 offset: usize,
3461 depth: fidl::encoding::Depth,
3462 ) -> fidl::Result<()> {
3463 encoder.debug_check_bounds::<BrowseControllerChangePathRequest>(offset);
3464 self.0.encode(encoder, offset + 0, depth)?;
3468 Ok(())
3469 }
3470 }
3471
3472 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3473 for BrowseControllerChangePathRequest
3474 {
3475 #[inline(always)]
3476 fn new_empty() -> Self {
3477 Self { path: fidl::new_empty!(Path, D) }
3478 }
3479
3480 #[inline]
3481 unsafe fn decode(
3482 &mut self,
3483 decoder: &mut fidl::encoding::Decoder<'_, D>,
3484 offset: usize,
3485 _depth: fidl::encoding::Depth,
3486 ) -> fidl::Result<()> {
3487 decoder.debug_check_bounds::<Self>(offset);
3488 fidl::decode!(Path, D, &mut self.path, decoder, offset + 0, _depth)?;
3490 Ok(())
3491 }
3492 }
3493
3494 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetFileSystemItemsRequest {
3495 type Borrowed<'a> = &'a Self;
3496 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3497 value
3498 }
3499 }
3500
3501 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetFileSystemItemsRequest {
3502 type Owned = Self;
3503
3504 #[inline(always)]
3505 fn inline_align(_context: fidl::encoding::Context) -> usize {
3506 8
3507 }
3508
3509 #[inline(always)]
3510 fn inline_size(_context: fidl::encoding::Context) -> usize {
3511 24
3512 }
3513 }
3514
3515 unsafe impl<D: fidl::encoding::ResourceDialect>
3516 fidl::encoding::Encode<BrowseControllerGetFileSystemItemsRequest, D>
3517 for &BrowseControllerGetFileSystemItemsRequest
3518 {
3519 #[inline]
3520 unsafe fn encode(
3521 self,
3522 encoder: &mut fidl::encoding::Encoder<'_, D>,
3523 offset: usize,
3524 _depth: fidl::encoding::Depth,
3525 ) -> fidl::Result<()> {
3526 encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsRequest>(offset);
3527 fidl::encoding::Encode::<BrowseControllerGetFileSystemItemsRequest, D>::encode(
3529 (
3530 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.start_index),
3531 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.end_index),
3532 <AttributeRequestOption as fidl::encoding::ValueTypeMarker>::borrow(
3533 &self.attribute_option,
3534 ),
3535 ),
3536 encoder,
3537 offset,
3538 _depth,
3539 )
3540 }
3541 }
3542 unsafe impl<
3543 D: fidl::encoding::ResourceDialect,
3544 T0: fidl::encoding::Encode<u32, D>,
3545 T1: fidl::encoding::Encode<u32, D>,
3546 T2: fidl::encoding::Encode<AttributeRequestOption, D>,
3547 > fidl::encoding::Encode<BrowseControllerGetFileSystemItemsRequest, D> for (T0, T1, T2)
3548 {
3549 #[inline]
3550 unsafe fn encode(
3551 self,
3552 encoder: &mut fidl::encoding::Encoder<'_, D>,
3553 offset: usize,
3554 depth: fidl::encoding::Depth,
3555 ) -> fidl::Result<()> {
3556 encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsRequest>(offset);
3557 self.0.encode(encoder, offset + 0, depth)?;
3561 self.1.encode(encoder, offset + 4, depth)?;
3562 self.2.encode(encoder, offset + 8, depth)?;
3563 Ok(())
3564 }
3565 }
3566
3567 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3568 for BrowseControllerGetFileSystemItemsRequest
3569 {
3570 #[inline(always)]
3571 fn new_empty() -> Self {
3572 Self {
3573 start_index: fidl::new_empty!(u32, D),
3574 end_index: fidl::new_empty!(u32, D),
3575 attribute_option: fidl::new_empty!(AttributeRequestOption, D),
3576 }
3577 }
3578
3579 #[inline]
3580 unsafe fn decode(
3581 &mut self,
3582 decoder: &mut fidl::encoding::Decoder<'_, D>,
3583 offset: usize,
3584 _depth: fidl::encoding::Depth,
3585 ) -> fidl::Result<()> {
3586 decoder.debug_check_bounds::<Self>(offset);
3587 fidl::decode!(u32, D, &mut self.start_index, decoder, offset + 0, _depth)?;
3589 fidl::decode!(u32, D, &mut self.end_index, decoder, offset + 4, _depth)?;
3590 fidl::decode!(
3591 AttributeRequestOption,
3592 D,
3593 &mut self.attribute_option,
3594 decoder,
3595 offset + 8,
3596 _depth
3597 )?;
3598 Ok(())
3599 }
3600 }
3601
3602 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetMediaPlayerItemsRequest {
3603 type Borrowed<'a> = &'a Self;
3604 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3605 value
3606 }
3607 }
3608
3609 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetMediaPlayerItemsRequest {
3610 type Owned = Self;
3611
3612 #[inline(always)]
3613 fn inline_align(_context: fidl::encoding::Context) -> usize {
3614 4
3615 }
3616
3617 #[inline(always)]
3618 fn inline_size(_context: fidl::encoding::Context) -> usize {
3619 8
3620 }
3621 #[inline(always)]
3622 fn encode_is_copy() -> bool {
3623 true
3624 }
3625
3626 #[inline(always)]
3627 fn decode_is_copy() -> bool {
3628 true
3629 }
3630 }
3631
3632 unsafe impl<D: fidl::encoding::ResourceDialect>
3633 fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsRequest, D>
3634 for &BrowseControllerGetMediaPlayerItemsRequest
3635 {
3636 #[inline]
3637 unsafe fn encode(
3638 self,
3639 encoder: &mut fidl::encoding::Encoder<'_, D>,
3640 offset: usize,
3641 _depth: fidl::encoding::Depth,
3642 ) -> fidl::Result<()> {
3643 encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsRequest>(offset);
3644 unsafe {
3645 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3647 (buf_ptr as *mut BrowseControllerGetMediaPlayerItemsRequest).write_unaligned(
3648 (self as *const BrowseControllerGetMediaPlayerItemsRequest).read(),
3649 );
3650 }
3653 Ok(())
3654 }
3655 }
3656 unsafe impl<
3657 D: fidl::encoding::ResourceDialect,
3658 T0: fidl::encoding::Encode<u32, D>,
3659 T1: fidl::encoding::Encode<u32, D>,
3660 > fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsRequest, D> for (T0, T1)
3661 {
3662 #[inline]
3663 unsafe fn encode(
3664 self,
3665 encoder: &mut fidl::encoding::Encoder<'_, D>,
3666 offset: usize,
3667 depth: fidl::encoding::Depth,
3668 ) -> fidl::Result<()> {
3669 encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsRequest>(offset);
3670 self.0.encode(encoder, offset + 0, depth)?;
3674 self.1.encode(encoder, offset + 4, depth)?;
3675 Ok(())
3676 }
3677 }
3678
3679 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3680 for BrowseControllerGetMediaPlayerItemsRequest
3681 {
3682 #[inline(always)]
3683 fn new_empty() -> Self {
3684 Self { start_index: fidl::new_empty!(u32, D), end_index: fidl::new_empty!(u32, D) }
3685 }
3686
3687 #[inline]
3688 unsafe fn decode(
3689 &mut self,
3690 decoder: &mut fidl::encoding::Decoder<'_, D>,
3691 offset: usize,
3692 _depth: fidl::encoding::Depth,
3693 ) -> fidl::Result<()> {
3694 decoder.debug_check_bounds::<Self>(offset);
3695 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3696 unsafe {
3699 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3700 }
3701 Ok(())
3702 }
3703 }
3704
3705 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetNowPlayingItemsRequest {
3706 type Borrowed<'a> = &'a Self;
3707 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3708 value
3709 }
3710 }
3711
3712 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetNowPlayingItemsRequest {
3713 type Owned = Self;
3714
3715 #[inline(always)]
3716 fn inline_align(_context: fidl::encoding::Context) -> usize {
3717 8
3718 }
3719
3720 #[inline(always)]
3721 fn inline_size(_context: fidl::encoding::Context) -> usize {
3722 24
3723 }
3724 }
3725
3726 unsafe impl<D: fidl::encoding::ResourceDialect>
3727 fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsRequest, D>
3728 for &BrowseControllerGetNowPlayingItemsRequest
3729 {
3730 #[inline]
3731 unsafe fn encode(
3732 self,
3733 encoder: &mut fidl::encoding::Encoder<'_, D>,
3734 offset: usize,
3735 _depth: fidl::encoding::Depth,
3736 ) -> fidl::Result<()> {
3737 encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsRequest>(offset);
3738 fidl::encoding::Encode::<BrowseControllerGetNowPlayingItemsRequest, D>::encode(
3740 (
3741 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.start_index),
3742 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.end_index),
3743 <AttributeRequestOption as fidl::encoding::ValueTypeMarker>::borrow(
3744 &self.attribute_option,
3745 ),
3746 ),
3747 encoder,
3748 offset,
3749 _depth,
3750 )
3751 }
3752 }
3753 unsafe impl<
3754 D: fidl::encoding::ResourceDialect,
3755 T0: fidl::encoding::Encode<u32, D>,
3756 T1: fidl::encoding::Encode<u32, D>,
3757 T2: fidl::encoding::Encode<AttributeRequestOption, D>,
3758 > fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsRequest, D> for (T0, T1, T2)
3759 {
3760 #[inline]
3761 unsafe fn encode(
3762 self,
3763 encoder: &mut fidl::encoding::Encoder<'_, D>,
3764 offset: usize,
3765 depth: fidl::encoding::Depth,
3766 ) -> fidl::Result<()> {
3767 encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsRequest>(offset);
3768 self.0.encode(encoder, offset + 0, depth)?;
3772 self.1.encode(encoder, offset + 4, depth)?;
3773 self.2.encode(encoder, offset + 8, depth)?;
3774 Ok(())
3775 }
3776 }
3777
3778 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3779 for BrowseControllerGetNowPlayingItemsRequest
3780 {
3781 #[inline(always)]
3782 fn new_empty() -> Self {
3783 Self {
3784 start_index: fidl::new_empty!(u32, D),
3785 end_index: fidl::new_empty!(u32, D),
3786 attribute_option: fidl::new_empty!(AttributeRequestOption, D),
3787 }
3788 }
3789
3790 #[inline]
3791 unsafe fn decode(
3792 &mut self,
3793 decoder: &mut fidl::encoding::Decoder<'_, D>,
3794 offset: usize,
3795 _depth: fidl::encoding::Depth,
3796 ) -> fidl::Result<()> {
3797 decoder.debug_check_bounds::<Self>(offset);
3798 fidl::decode!(u32, D, &mut self.start_index, decoder, offset + 0, _depth)?;
3800 fidl::decode!(u32, D, &mut self.end_index, decoder, offset + 4, _depth)?;
3801 fidl::decode!(
3802 AttributeRequestOption,
3803 D,
3804 &mut self.attribute_option,
3805 decoder,
3806 offset + 8,
3807 _depth
3808 )?;
3809 Ok(())
3810 }
3811 }
3812
3813 impl fidl::encoding::ValueTypeMarker for BrowseControllerPlayFileSystemItemRequest {
3814 type Borrowed<'a> = &'a Self;
3815 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3816 value
3817 }
3818 }
3819
3820 unsafe impl fidl::encoding::TypeMarker for BrowseControllerPlayFileSystemItemRequest {
3821 type Owned = Self;
3822
3823 #[inline(always)]
3824 fn inline_align(_context: fidl::encoding::Context) -> usize {
3825 8
3826 }
3827
3828 #[inline(always)]
3829 fn inline_size(_context: fidl::encoding::Context) -> usize {
3830 8
3831 }
3832 #[inline(always)]
3833 fn encode_is_copy() -> bool {
3834 true
3835 }
3836
3837 #[inline(always)]
3838 fn decode_is_copy() -> bool {
3839 true
3840 }
3841 }
3842
3843 unsafe impl<D: fidl::encoding::ResourceDialect>
3844 fidl::encoding::Encode<BrowseControllerPlayFileSystemItemRequest, D>
3845 for &BrowseControllerPlayFileSystemItemRequest
3846 {
3847 #[inline]
3848 unsafe fn encode(
3849 self,
3850 encoder: &mut fidl::encoding::Encoder<'_, D>,
3851 offset: usize,
3852 _depth: fidl::encoding::Depth,
3853 ) -> fidl::Result<()> {
3854 encoder.debug_check_bounds::<BrowseControllerPlayFileSystemItemRequest>(offset);
3855 unsafe {
3856 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3858 (buf_ptr as *mut BrowseControllerPlayFileSystemItemRequest).write_unaligned(
3859 (self as *const BrowseControllerPlayFileSystemItemRequest).read(),
3860 );
3861 }
3864 Ok(())
3865 }
3866 }
3867 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
3868 fidl::encoding::Encode<BrowseControllerPlayFileSystemItemRequest, D> for (T0,)
3869 {
3870 #[inline]
3871 unsafe fn encode(
3872 self,
3873 encoder: &mut fidl::encoding::Encoder<'_, D>,
3874 offset: usize,
3875 depth: fidl::encoding::Depth,
3876 ) -> fidl::Result<()> {
3877 encoder.debug_check_bounds::<BrowseControllerPlayFileSystemItemRequest>(offset);
3878 self.0.encode(encoder, offset + 0, depth)?;
3882 Ok(())
3883 }
3884 }
3885
3886 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3887 for BrowseControllerPlayFileSystemItemRequest
3888 {
3889 #[inline(always)]
3890 fn new_empty() -> Self {
3891 Self { uid: fidl::new_empty!(u64, D) }
3892 }
3893
3894 #[inline]
3895 unsafe fn decode(
3896 &mut self,
3897 decoder: &mut fidl::encoding::Decoder<'_, D>,
3898 offset: usize,
3899 _depth: fidl::encoding::Depth,
3900 ) -> fidl::Result<()> {
3901 decoder.debug_check_bounds::<Self>(offset);
3902 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
3903 unsafe {
3906 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
3907 }
3908 Ok(())
3909 }
3910 }
3911
3912 impl fidl::encoding::ValueTypeMarker for BrowseControllerPlayNowPlayingItemRequest {
3913 type Borrowed<'a> = &'a Self;
3914 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3915 value
3916 }
3917 }
3918
3919 unsafe impl fidl::encoding::TypeMarker for BrowseControllerPlayNowPlayingItemRequest {
3920 type Owned = Self;
3921
3922 #[inline(always)]
3923 fn inline_align(_context: fidl::encoding::Context) -> usize {
3924 8
3925 }
3926
3927 #[inline(always)]
3928 fn inline_size(_context: fidl::encoding::Context) -> usize {
3929 8
3930 }
3931 #[inline(always)]
3932 fn encode_is_copy() -> bool {
3933 true
3934 }
3935
3936 #[inline(always)]
3937 fn decode_is_copy() -> bool {
3938 true
3939 }
3940 }
3941
3942 unsafe impl<D: fidl::encoding::ResourceDialect>
3943 fidl::encoding::Encode<BrowseControllerPlayNowPlayingItemRequest, D>
3944 for &BrowseControllerPlayNowPlayingItemRequest
3945 {
3946 #[inline]
3947 unsafe fn encode(
3948 self,
3949 encoder: &mut fidl::encoding::Encoder<'_, D>,
3950 offset: usize,
3951 _depth: fidl::encoding::Depth,
3952 ) -> fidl::Result<()> {
3953 encoder.debug_check_bounds::<BrowseControllerPlayNowPlayingItemRequest>(offset);
3954 unsafe {
3955 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
3957 (buf_ptr as *mut BrowseControllerPlayNowPlayingItemRequest).write_unaligned(
3958 (self as *const BrowseControllerPlayNowPlayingItemRequest).read(),
3959 );
3960 }
3963 Ok(())
3964 }
3965 }
3966 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
3967 fidl::encoding::Encode<BrowseControllerPlayNowPlayingItemRequest, D> for (T0,)
3968 {
3969 #[inline]
3970 unsafe fn encode(
3971 self,
3972 encoder: &mut fidl::encoding::Encoder<'_, D>,
3973 offset: usize,
3974 depth: fidl::encoding::Depth,
3975 ) -> fidl::Result<()> {
3976 encoder.debug_check_bounds::<BrowseControllerPlayNowPlayingItemRequest>(offset);
3977 self.0.encode(encoder, offset + 0, depth)?;
3981 Ok(())
3982 }
3983 }
3984
3985 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3986 for BrowseControllerPlayNowPlayingItemRequest
3987 {
3988 #[inline(always)]
3989 fn new_empty() -> Self {
3990 Self { uid: fidl::new_empty!(u64, D) }
3991 }
3992
3993 #[inline]
3994 unsafe fn decode(
3995 &mut self,
3996 decoder: &mut fidl::encoding::Decoder<'_, D>,
3997 offset: usize,
3998 _depth: fidl::encoding::Depth,
3999 ) -> fidl::Result<()> {
4000 decoder.debug_check_bounds::<Self>(offset);
4001 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4002 unsafe {
4005 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
4006 }
4007 Ok(())
4008 }
4009 }
4010
4011 impl fidl::encoding::ValueTypeMarker for BrowseControllerSetBrowsedPlayerRequest {
4012 type Borrowed<'a> = &'a Self;
4013 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4014 value
4015 }
4016 }
4017
4018 unsafe impl fidl::encoding::TypeMarker for BrowseControllerSetBrowsedPlayerRequest {
4019 type Owned = Self;
4020
4021 #[inline(always)]
4022 fn inline_align(_context: fidl::encoding::Context) -> usize {
4023 2
4024 }
4025
4026 #[inline(always)]
4027 fn inline_size(_context: fidl::encoding::Context) -> usize {
4028 2
4029 }
4030 #[inline(always)]
4031 fn encode_is_copy() -> bool {
4032 true
4033 }
4034
4035 #[inline(always)]
4036 fn decode_is_copy() -> bool {
4037 true
4038 }
4039 }
4040
4041 unsafe impl<D: fidl::encoding::ResourceDialect>
4042 fidl::encoding::Encode<BrowseControllerSetBrowsedPlayerRequest, D>
4043 for &BrowseControllerSetBrowsedPlayerRequest
4044 {
4045 #[inline]
4046 unsafe fn encode(
4047 self,
4048 encoder: &mut fidl::encoding::Encoder<'_, D>,
4049 offset: usize,
4050 _depth: fidl::encoding::Depth,
4051 ) -> fidl::Result<()> {
4052 encoder.debug_check_bounds::<BrowseControllerSetBrowsedPlayerRequest>(offset);
4053 unsafe {
4054 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4056 (buf_ptr as *mut BrowseControllerSetBrowsedPlayerRequest).write_unaligned(
4057 (self as *const BrowseControllerSetBrowsedPlayerRequest).read(),
4058 );
4059 }
4062 Ok(())
4063 }
4064 }
4065 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
4066 fidl::encoding::Encode<BrowseControllerSetBrowsedPlayerRequest, D> for (T0,)
4067 {
4068 #[inline]
4069 unsafe fn encode(
4070 self,
4071 encoder: &mut fidl::encoding::Encoder<'_, D>,
4072 offset: usize,
4073 depth: fidl::encoding::Depth,
4074 ) -> fidl::Result<()> {
4075 encoder.debug_check_bounds::<BrowseControllerSetBrowsedPlayerRequest>(offset);
4076 self.0.encode(encoder, offset + 0, depth)?;
4080 Ok(())
4081 }
4082 }
4083
4084 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4085 for BrowseControllerSetBrowsedPlayerRequest
4086 {
4087 #[inline(always)]
4088 fn new_empty() -> Self {
4089 Self { player_id: fidl::new_empty!(u16, D) }
4090 }
4091
4092 #[inline]
4093 unsafe fn decode(
4094 &mut self,
4095 decoder: &mut fidl::encoding::Decoder<'_, D>,
4096 offset: usize,
4097 _depth: fidl::encoding::Depth,
4098 ) -> fidl::Result<()> {
4099 decoder.debug_check_bounds::<Self>(offset);
4100 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4101 unsafe {
4104 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
4105 }
4106 Ok(())
4107 }
4108 }
4109
4110 impl fidl::encoding::ValueTypeMarker for BrowseControllerChangePathResponse {
4111 type Borrowed<'a> = &'a Self;
4112 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4113 value
4114 }
4115 }
4116
4117 unsafe impl fidl::encoding::TypeMarker for BrowseControllerChangePathResponse {
4118 type Owned = Self;
4119
4120 #[inline(always)]
4121 fn inline_align(_context: fidl::encoding::Context) -> usize {
4122 4
4123 }
4124
4125 #[inline(always)]
4126 fn inline_size(_context: fidl::encoding::Context) -> usize {
4127 4
4128 }
4129 #[inline(always)]
4130 fn encode_is_copy() -> bool {
4131 true
4132 }
4133
4134 #[inline(always)]
4135 fn decode_is_copy() -> bool {
4136 true
4137 }
4138 }
4139
4140 unsafe impl<D: fidl::encoding::ResourceDialect>
4141 fidl::encoding::Encode<BrowseControllerChangePathResponse, D>
4142 for &BrowseControllerChangePathResponse
4143 {
4144 #[inline]
4145 unsafe fn encode(
4146 self,
4147 encoder: &mut fidl::encoding::Encoder<'_, D>,
4148 offset: usize,
4149 _depth: fidl::encoding::Depth,
4150 ) -> fidl::Result<()> {
4151 encoder.debug_check_bounds::<BrowseControllerChangePathResponse>(offset);
4152 unsafe {
4153 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4155 (buf_ptr as *mut BrowseControllerChangePathResponse)
4156 .write_unaligned((self as *const BrowseControllerChangePathResponse).read());
4157 }
4160 Ok(())
4161 }
4162 }
4163 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u32, D>>
4164 fidl::encoding::Encode<BrowseControllerChangePathResponse, D> for (T0,)
4165 {
4166 #[inline]
4167 unsafe fn encode(
4168 self,
4169 encoder: &mut fidl::encoding::Encoder<'_, D>,
4170 offset: usize,
4171 depth: fidl::encoding::Depth,
4172 ) -> fidl::Result<()> {
4173 encoder.debug_check_bounds::<BrowseControllerChangePathResponse>(offset);
4174 self.0.encode(encoder, offset + 0, depth)?;
4178 Ok(())
4179 }
4180 }
4181
4182 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4183 for BrowseControllerChangePathResponse
4184 {
4185 #[inline(always)]
4186 fn new_empty() -> Self {
4187 Self { num_items: fidl::new_empty!(u32, D) }
4188 }
4189
4190 #[inline]
4191 unsafe fn decode(
4192 &mut self,
4193 decoder: &mut fidl::encoding::Decoder<'_, D>,
4194 offset: usize,
4195 _depth: fidl::encoding::Depth,
4196 ) -> fidl::Result<()> {
4197 decoder.debug_check_bounds::<Self>(offset);
4198 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4199 unsafe {
4202 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
4203 }
4204 Ok(())
4205 }
4206 }
4207
4208 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetFileSystemItemsResponse {
4209 type Borrowed<'a> = &'a Self;
4210 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4211 value
4212 }
4213 }
4214
4215 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetFileSystemItemsResponse {
4216 type Owned = Self;
4217
4218 #[inline(always)]
4219 fn inline_align(_context: fidl::encoding::Context) -> usize {
4220 8
4221 }
4222
4223 #[inline(always)]
4224 fn inline_size(_context: fidl::encoding::Context) -> usize {
4225 16
4226 }
4227 }
4228
4229 unsafe impl<D: fidl::encoding::ResourceDialect>
4230 fidl::encoding::Encode<BrowseControllerGetFileSystemItemsResponse, D>
4231 for &BrowseControllerGetFileSystemItemsResponse
4232 {
4233 #[inline]
4234 unsafe fn encode(
4235 self,
4236 encoder: &mut fidl::encoding::Encoder<'_, D>,
4237 offset: usize,
4238 _depth: fidl::encoding::Depth,
4239 ) -> fidl::Result<()> {
4240 encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsResponse>(offset);
4241 fidl::encoding::Encode::<BrowseControllerGetFileSystemItemsResponse, D>::encode(
4243 (
4244 <fidl::encoding::Vector<FileSystemItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4245 ),
4246 encoder, offset, _depth
4247 )
4248 }
4249 }
4250 unsafe impl<
4251 D: fidl::encoding::ResourceDialect,
4252 T0: fidl::encoding::Encode<fidl::encoding::Vector<FileSystemItem, 16>, D>,
4253 > fidl::encoding::Encode<BrowseControllerGetFileSystemItemsResponse, D> for (T0,)
4254 {
4255 #[inline]
4256 unsafe fn encode(
4257 self,
4258 encoder: &mut fidl::encoding::Encoder<'_, D>,
4259 offset: usize,
4260 depth: fidl::encoding::Depth,
4261 ) -> fidl::Result<()> {
4262 encoder.debug_check_bounds::<BrowseControllerGetFileSystemItemsResponse>(offset);
4263 self.0.encode(encoder, offset + 0, depth)?;
4267 Ok(())
4268 }
4269 }
4270
4271 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4272 for BrowseControllerGetFileSystemItemsResponse
4273 {
4274 #[inline(always)]
4275 fn new_empty() -> Self {
4276 Self { items: fidl::new_empty!(fidl::encoding::Vector<FileSystemItem, 16>, D) }
4277 }
4278
4279 #[inline]
4280 unsafe fn decode(
4281 &mut self,
4282 decoder: &mut fidl::encoding::Decoder<'_, D>,
4283 offset: usize,
4284 _depth: fidl::encoding::Depth,
4285 ) -> fidl::Result<()> {
4286 decoder.debug_check_bounds::<Self>(offset);
4287 fidl::decode!(fidl::encoding::Vector<FileSystemItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4289 Ok(())
4290 }
4291 }
4292
4293 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetMediaPlayerItemsResponse {
4294 type Borrowed<'a> = &'a Self;
4295 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4296 value
4297 }
4298 }
4299
4300 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetMediaPlayerItemsResponse {
4301 type Owned = Self;
4302
4303 #[inline(always)]
4304 fn inline_align(_context: fidl::encoding::Context) -> usize {
4305 8
4306 }
4307
4308 #[inline(always)]
4309 fn inline_size(_context: fidl::encoding::Context) -> usize {
4310 16
4311 }
4312 }
4313
4314 unsafe impl<D: fidl::encoding::ResourceDialect>
4315 fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsResponse, D>
4316 for &BrowseControllerGetMediaPlayerItemsResponse
4317 {
4318 #[inline]
4319 unsafe fn encode(
4320 self,
4321 encoder: &mut fidl::encoding::Encoder<'_, D>,
4322 offset: usize,
4323 _depth: fidl::encoding::Depth,
4324 ) -> fidl::Result<()> {
4325 encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsResponse>(offset);
4326 fidl::encoding::Encode::<BrowseControllerGetMediaPlayerItemsResponse, D>::encode(
4328 (
4329 <fidl::encoding::Vector<MediaPlayerItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4330 ),
4331 encoder, offset, _depth
4332 )
4333 }
4334 }
4335 unsafe impl<
4336 D: fidl::encoding::ResourceDialect,
4337 T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaPlayerItem, 16>, D>,
4338 > fidl::encoding::Encode<BrowseControllerGetMediaPlayerItemsResponse, D> for (T0,)
4339 {
4340 #[inline]
4341 unsafe fn encode(
4342 self,
4343 encoder: &mut fidl::encoding::Encoder<'_, D>,
4344 offset: usize,
4345 depth: fidl::encoding::Depth,
4346 ) -> fidl::Result<()> {
4347 encoder.debug_check_bounds::<BrowseControllerGetMediaPlayerItemsResponse>(offset);
4348 self.0.encode(encoder, offset + 0, depth)?;
4352 Ok(())
4353 }
4354 }
4355
4356 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4357 for BrowseControllerGetMediaPlayerItemsResponse
4358 {
4359 #[inline(always)]
4360 fn new_empty() -> Self {
4361 Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaPlayerItem, 16>, D) }
4362 }
4363
4364 #[inline]
4365 unsafe fn decode(
4366 &mut self,
4367 decoder: &mut fidl::encoding::Decoder<'_, D>,
4368 offset: usize,
4369 _depth: fidl::encoding::Depth,
4370 ) -> fidl::Result<()> {
4371 decoder.debug_check_bounds::<Self>(offset);
4372 fidl::decode!(fidl::encoding::Vector<MediaPlayerItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4374 Ok(())
4375 }
4376 }
4377
4378 impl fidl::encoding::ValueTypeMarker for BrowseControllerGetNowPlayingItemsResponse {
4379 type Borrowed<'a> = &'a Self;
4380 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4381 value
4382 }
4383 }
4384
4385 unsafe impl fidl::encoding::TypeMarker for BrowseControllerGetNowPlayingItemsResponse {
4386 type Owned = Self;
4387
4388 #[inline(always)]
4389 fn inline_align(_context: fidl::encoding::Context) -> usize {
4390 8
4391 }
4392
4393 #[inline(always)]
4394 fn inline_size(_context: fidl::encoding::Context) -> usize {
4395 16
4396 }
4397 }
4398
4399 unsafe impl<D: fidl::encoding::ResourceDialect>
4400 fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsResponse, D>
4401 for &BrowseControllerGetNowPlayingItemsResponse
4402 {
4403 #[inline]
4404 unsafe fn encode(
4405 self,
4406 encoder: &mut fidl::encoding::Encoder<'_, D>,
4407 offset: usize,
4408 _depth: fidl::encoding::Depth,
4409 ) -> fidl::Result<()> {
4410 encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsResponse>(offset);
4411 fidl::encoding::Encode::<BrowseControllerGetNowPlayingItemsResponse, D>::encode(
4413 (
4414 <fidl::encoding::Vector<MediaElementItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
4415 ),
4416 encoder, offset, _depth
4417 )
4418 }
4419 }
4420 unsafe impl<
4421 D: fidl::encoding::ResourceDialect,
4422 T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaElementItem, 16>, D>,
4423 > fidl::encoding::Encode<BrowseControllerGetNowPlayingItemsResponse, D> for (T0,)
4424 {
4425 #[inline]
4426 unsafe fn encode(
4427 self,
4428 encoder: &mut fidl::encoding::Encoder<'_, D>,
4429 offset: usize,
4430 depth: fidl::encoding::Depth,
4431 ) -> fidl::Result<()> {
4432 encoder.debug_check_bounds::<BrowseControllerGetNowPlayingItemsResponse>(offset);
4433 self.0.encode(encoder, offset + 0, depth)?;
4437 Ok(())
4438 }
4439 }
4440
4441 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4442 for BrowseControllerGetNowPlayingItemsResponse
4443 {
4444 #[inline(always)]
4445 fn new_empty() -> Self {
4446 Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaElementItem, 16>, D) }
4447 }
4448
4449 #[inline]
4450 unsafe fn decode(
4451 &mut self,
4452 decoder: &mut fidl::encoding::Decoder<'_, D>,
4453 offset: usize,
4454 _depth: fidl::encoding::Depth,
4455 ) -> fidl::Result<()> {
4456 decoder.debug_check_bounds::<Self>(offset);
4457 fidl::decode!(fidl::encoding::Vector<MediaElementItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
4459 Ok(())
4460 }
4461 }
4462
4463 impl fidl::encoding::ValueTypeMarker for ControllerGetPlayerApplicationSettingsRequest {
4464 type Borrowed<'a> = &'a Self;
4465 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4466 value
4467 }
4468 }
4469
4470 unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayerApplicationSettingsRequest {
4471 type Owned = Self;
4472
4473 #[inline(always)]
4474 fn inline_align(_context: fidl::encoding::Context) -> usize {
4475 8
4476 }
4477
4478 #[inline(always)]
4479 fn inline_size(_context: fidl::encoding::Context) -> usize {
4480 16
4481 }
4482 }
4483
4484 unsafe impl<D: fidl::encoding::ResourceDialect>
4485 fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsRequest, D>
4486 for &ControllerGetPlayerApplicationSettingsRequest
4487 {
4488 #[inline]
4489 unsafe fn encode(
4490 self,
4491 encoder: &mut fidl::encoding::Encoder<'_, D>,
4492 offset: usize,
4493 _depth: fidl::encoding::Depth,
4494 ) -> fidl::Result<()> {
4495 encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsRequest>(offset);
4496 fidl::encoding::Encode::<ControllerGetPlayerApplicationSettingsRequest, D>::encode(
4498 (
4499 <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attribute_ids),
4500 ),
4501 encoder, offset, _depth
4502 )
4503 }
4504 }
4505 unsafe impl<
4506 D: fidl::encoding::ResourceDialect,
4507 T0: fidl::encoding::Encode<
4508 fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
4509 D,
4510 >,
4511 > fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsRequest, D> for (T0,)
4512 {
4513 #[inline]
4514 unsafe fn encode(
4515 self,
4516 encoder: &mut fidl::encoding::Encoder<'_, D>,
4517 offset: usize,
4518 depth: fidl::encoding::Depth,
4519 ) -> fidl::Result<()> {
4520 encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsRequest>(offset);
4521 self.0.encode(encoder, offset + 0, depth)?;
4525 Ok(())
4526 }
4527 }
4528
4529 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4530 for ControllerGetPlayerApplicationSettingsRequest
4531 {
4532 #[inline(always)]
4533 fn new_empty() -> Self {
4534 Self {
4535 attribute_ids: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
4536 }
4537 }
4538
4539 #[inline]
4540 unsafe fn decode(
4541 &mut self,
4542 decoder: &mut fidl::encoding::Decoder<'_, D>,
4543 offset: usize,
4544 _depth: fidl::encoding::Depth,
4545 ) -> fidl::Result<()> {
4546 decoder.debug_check_bounds::<Self>(offset);
4547 fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attribute_ids, decoder, offset + 0, _depth)?;
4549 Ok(())
4550 }
4551 }
4552
4553 impl fidl::encoding::ValueTypeMarker for ControllerInformBatteryStatusRequest {
4554 type Borrowed<'a> = &'a Self;
4555 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4556 value
4557 }
4558 }
4559
4560 unsafe impl fidl::encoding::TypeMarker for ControllerInformBatteryStatusRequest {
4561 type Owned = Self;
4562
4563 #[inline(always)]
4564 fn inline_align(_context: fidl::encoding::Context) -> usize {
4565 1
4566 }
4567
4568 #[inline(always)]
4569 fn inline_size(_context: fidl::encoding::Context) -> usize {
4570 1
4571 }
4572 }
4573
4574 unsafe impl<D: fidl::encoding::ResourceDialect>
4575 fidl::encoding::Encode<ControllerInformBatteryStatusRequest, D>
4576 for &ControllerInformBatteryStatusRequest
4577 {
4578 #[inline]
4579 unsafe fn encode(
4580 self,
4581 encoder: &mut fidl::encoding::Encoder<'_, D>,
4582 offset: usize,
4583 _depth: fidl::encoding::Depth,
4584 ) -> fidl::Result<()> {
4585 encoder.debug_check_bounds::<ControllerInformBatteryStatusRequest>(offset);
4586 fidl::encoding::Encode::<ControllerInformBatteryStatusRequest, D>::encode(
4588 (<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.battery_status),),
4589 encoder,
4590 offset,
4591 _depth,
4592 )
4593 }
4594 }
4595 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BatteryStatus, D>>
4596 fidl::encoding::Encode<ControllerInformBatteryStatusRequest, D> for (T0,)
4597 {
4598 #[inline]
4599 unsafe fn encode(
4600 self,
4601 encoder: &mut fidl::encoding::Encoder<'_, D>,
4602 offset: usize,
4603 depth: fidl::encoding::Depth,
4604 ) -> fidl::Result<()> {
4605 encoder.debug_check_bounds::<ControllerInformBatteryStatusRequest>(offset);
4606 self.0.encode(encoder, offset + 0, depth)?;
4610 Ok(())
4611 }
4612 }
4613
4614 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4615 for ControllerInformBatteryStatusRequest
4616 {
4617 #[inline(always)]
4618 fn new_empty() -> Self {
4619 Self { battery_status: fidl::new_empty!(BatteryStatus, D) }
4620 }
4621
4622 #[inline]
4623 unsafe fn decode(
4624 &mut self,
4625 decoder: &mut fidl::encoding::Decoder<'_, D>,
4626 offset: usize,
4627 _depth: fidl::encoding::Depth,
4628 ) -> fidl::Result<()> {
4629 decoder.debug_check_bounds::<Self>(offset);
4630 fidl::decode!(BatteryStatus, D, &mut self.battery_status, decoder, offset + 0, _depth)?;
4632 Ok(())
4633 }
4634 }
4635
4636 impl fidl::encoding::ValueTypeMarker for ControllerOnNotificationRequest {
4637 type Borrowed<'a> = &'a Self;
4638 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4639 value
4640 }
4641 }
4642
4643 unsafe impl fidl::encoding::TypeMarker for ControllerOnNotificationRequest {
4644 type Owned = Self;
4645
4646 #[inline(always)]
4647 fn inline_align(_context: fidl::encoding::Context) -> usize {
4648 8
4649 }
4650
4651 #[inline(always)]
4652 fn inline_size(_context: fidl::encoding::Context) -> usize {
4653 24
4654 }
4655 }
4656
4657 unsafe impl<D: fidl::encoding::ResourceDialect>
4658 fidl::encoding::Encode<ControllerOnNotificationRequest, D>
4659 for &ControllerOnNotificationRequest
4660 {
4661 #[inline]
4662 unsafe fn encode(
4663 self,
4664 encoder: &mut fidl::encoding::Encoder<'_, D>,
4665 offset: usize,
4666 _depth: fidl::encoding::Depth,
4667 ) -> fidl::Result<()> {
4668 encoder.debug_check_bounds::<ControllerOnNotificationRequest>(offset);
4669 fidl::encoding::Encode::<ControllerOnNotificationRequest, D>::encode(
4671 (
4672 <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
4673 <Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.notification),
4674 ),
4675 encoder,
4676 offset,
4677 _depth,
4678 )
4679 }
4680 }
4681 unsafe impl<
4682 D: fidl::encoding::ResourceDialect,
4683 T0: fidl::encoding::Encode<i64, D>,
4684 T1: fidl::encoding::Encode<Notification, D>,
4685 > fidl::encoding::Encode<ControllerOnNotificationRequest, D> for (T0, T1)
4686 {
4687 #[inline]
4688 unsafe fn encode(
4689 self,
4690 encoder: &mut fidl::encoding::Encoder<'_, D>,
4691 offset: usize,
4692 depth: fidl::encoding::Depth,
4693 ) -> fidl::Result<()> {
4694 encoder.debug_check_bounds::<ControllerOnNotificationRequest>(offset);
4695 self.0.encode(encoder, offset + 0, depth)?;
4699 self.1.encode(encoder, offset + 8, depth)?;
4700 Ok(())
4701 }
4702 }
4703
4704 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4705 for ControllerOnNotificationRequest
4706 {
4707 #[inline(always)]
4708 fn new_empty() -> Self {
4709 Self {
4710 timestamp: fidl::new_empty!(i64, D),
4711 notification: fidl::new_empty!(Notification, D),
4712 }
4713 }
4714
4715 #[inline]
4716 unsafe fn decode(
4717 &mut self,
4718 decoder: &mut fidl::encoding::Decoder<'_, D>,
4719 offset: usize,
4720 _depth: fidl::encoding::Depth,
4721 ) -> fidl::Result<()> {
4722 decoder.debug_check_bounds::<Self>(offset);
4723 fidl::decode!(i64, D, &mut self.timestamp, decoder, offset + 0, _depth)?;
4725 fidl::decode!(Notification, D, &mut self.notification, decoder, offset + 8, _depth)?;
4726 Ok(())
4727 }
4728 }
4729
4730 impl fidl::encoding::ValueTypeMarker for ControllerSendCommandRequest {
4731 type Borrowed<'a> = &'a Self;
4732 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4733 value
4734 }
4735 }
4736
4737 unsafe impl fidl::encoding::TypeMarker for ControllerSendCommandRequest {
4738 type Owned = Self;
4739
4740 #[inline(always)]
4741 fn inline_align(_context: fidl::encoding::Context) -> usize {
4742 1
4743 }
4744
4745 #[inline(always)]
4746 fn inline_size(_context: fidl::encoding::Context) -> usize {
4747 1
4748 }
4749 }
4750
4751 unsafe impl<D: fidl::encoding::ResourceDialect>
4752 fidl::encoding::Encode<ControllerSendCommandRequest, D> for &ControllerSendCommandRequest
4753 {
4754 #[inline]
4755 unsafe fn encode(
4756 self,
4757 encoder: &mut fidl::encoding::Encoder<'_, D>,
4758 offset: usize,
4759 _depth: fidl::encoding::Depth,
4760 ) -> fidl::Result<()> {
4761 encoder.debug_check_bounds::<ControllerSendCommandRequest>(offset);
4762 fidl::encoding::Encode::<ControllerSendCommandRequest, D>::encode(
4764 (<AvcPanelCommand as fidl::encoding::ValueTypeMarker>::borrow(&self.command),),
4765 encoder,
4766 offset,
4767 _depth,
4768 )
4769 }
4770 }
4771 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AvcPanelCommand, D>>
4772 fidl::encoding::Encode<ControllerSendCommandRequest, D> for (T0,)
4773 {
4774 #[inline]
4775 unsafe fn encode(
4776 self,
4777 encoder: &mut fidl::encoding::Encoder<'_, D>,
4778 offset: usize,
4779 depth: fidl::encoding::Depth,
4780 ) -> fidl::Result<()> {
4781 encoder.debug_check_bounds::<ControllerSendCommandRequest>(offset);
4782 self.0.encode(encoder, offset + 0, depth)?;
4786 Ok(())
4787 }
4788 }
4789
4790 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4791 for ControllerSendCommandRequest
4792 {
4793 #[inline(always)]
4794 fn new_empty() -> Self {
4795 Self { command: fidl::new_empty!(AvcPanelCommand, D) }
4796 }
4797
4798 #[inline]
4799 unsafe fn decode(
4800 &mut self,
4801 decoder: &mut fidl::encoding::Decoder<'_, D>,
4802 offset: usize,
4803 _depth: fidl::encoding::Depth,
4804 ) -> fidl::Result<()> {
4805 decoder.debug_check_bounds::<Self>(offset);
4806 fidl::decode!(AvcPanelCommand, D, &mut self.command, decoder, offset + 0, _depth)?;
4808 Ok(())
4809 }
4810 }
4811
4812 impl fidl::encoding::ValueTypeMarker for ControllerSetAbsoluteVolumeRequest {
4813 type Borrowed<'a> = &'a Self;
4814 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4815 value
4816 }
4817 }
4818
4819 unsafe impl fidl::encoding::TypeMarker for ControllerSetAbsoluteVolumeRequest {
4820 type Owned = Self;
4821
4822 #[inline(always)]
4823 fn inline_align(_context: fidl::encoding::Context) -> usize {
4824 1
4825 }
4826
4827 #[inline(always)]
4828 fn inline_size(_context: fidl::encoding::Context) -> usize {
4829 1
4830 }
4831 #[inline(always)]
4832 fn encode_is_copy() -> bool {
4833 true
4834 }
4835
4836 #[inline(always)]
4837 fn decode_is_copy() -> bool {
4838 true
4839 }
4840 }
4841
4842 unsafe impl<D: fidl::encoding::ResourceDialect>
4843 fidl::encoding::Encode<ControllerSetAbsoluteVolumeRequest, D>
4844 for &ControllerSetAbsoluteVolumeRequest
4845 {
4846 #[inline]
4847 unsafe fn encode(
4848 self,
4849 encoder: &mut fidl::encoding::Encoder<'_, D>,
4850 offset: usize,
4851 _depth: fidl::encoding::Depth,
4852 ) -> fidl::Result<()> {
4853 encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeRequest>(offset);
4854 unsafe {
4855 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4857 (buf_ptr as *mut ControllerSetAbsoluteVolumeRequest)
4858 .write_unaligned((self as *const ControllerSetAbsoluteVolumeRequest).read());
4859 }
4862 Ok(())
4863 }
4864 }
4865 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
4866 fidl::encoding::Encode<ControllerSetAbsoluteVolumeRequest, D> for (T0,)
4867 {
4868 #[inline]
4869 unsafe fn encode(
4870 self,
4871 encoder: &mut fidl::encoding::Encoder<'_, D>,
4872 offset: usize,
4873 depth: fidl::encoding::Depth,
4874 ) -> fidl::Result<()> {
4875 encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeRequest>(offset);
4876 self.0.encode(encoder, offset + 0, depth)?;
4880 Ok(())
4881 }
4882 }
4883
4884 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4885 for ControllerSetAbsoluteVolumeRequest
4886 {
4887 #[inline(always)]
4888 fn new_empty() -> Self {
4889 Self { requested_volume: fidl::new_empty!(u8, D) }
4890 }
4891
4892 #[inline]
4893 unsafe fn decode(
4894 &mut self,
4895 decoder: &mut fidl::encoding::Decoder<'_, D>,
4896 offset: usize,
4897 _depth: fidl::encoding::Depth,
4898 ) -> fidl::Result<()> {
4899 decoder.debug_check_bounds::<Self>(offset);
4900 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4901 unsafe {
4904 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
4905 }
4906 Ok(())
4907 }
4908 }
4909
4910 impl fidl::encoding::ValueTypeMarker for ControllerSetAddressedPlayerRequest {
4911 type Borrowed<'a> = &'a Self;
4912 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4913 value
4914 }
4915 }
4916
4917 unsafe impl fidl::encoding::TypeMarker for ControllerSetAddressedPlayerRequest {
4918 type Owned = Self;
4919
4920 #[inline(always)]
4921 fn inline_align(_context: fidl::encoding::Context) -> usize {
4922 2
4923 }
4924
4925 #[inline(always)]
4926 fn inline_size(_context: fidl::encoding::Context) -> usize {
4927 2
4928 }
4929 #[inline(always)]
4930 fn encode_is_copy() -> bool {
4931 true
4932 }
4933
4934 #[inline(always)]
4935 fn decode_is_copy() -> bool {
4936 true
4937 }
4938 }
4939
4940 unsafe impl<D: fidl::encoding::ResourceDialect>
4941 fidl::encoding::Encode<ControllerSetAddressedPlayerRequest, D>
4942 for &ControllerSetAddressedPlayerRequest
4943 {
4944 #[inline]
4945 unsafe fn encode(
4946 self,
4947 encoder: &mut fidl::encoding::Encoder<'_, D>,
4948 offset: usize,
4949 _depth: fidl::encoding::Depth,
4950 ) -> fidl::Result<()> {
4951 encoder.debug_check_bounds::<ControllerSetAddressedPlayerRequest>(offset);
4952 unsafe {
4953 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
4955 (buf_ptr as *mut ControllerSetAddressedPlayerRequest)
4956 .write_unaligned((self as *const ControllerSetAddressedPlayerRequest).read());
4957 }
4960 Ok(())
4961 }
4962 }
4963 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
4964 fidl::encoding::Encode<ControllerSetAddressedPlayerRequest, D> for (T0,)
4965 {
4966 #[inline]
4967 unsafe fn encode(
4968 self,
4969 encoder: &mut fidl::encoding::Encoder<'_, D>,
4970 offset: usize,
4971 depth: fidl::encoding::Depth,
4972 ) -> fidl::Result<()> {
4973 encoder.debug_check_bounds::<ControllerSetAddressedPlayerRequest>(offset);
4974 self.0.encode(encoder, offset + 0, depth)?;
4978 Ok(())
4979 }
4980 }
4981
4982 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4983 for ControllerSetAddressedPlayerRequest
4984 {
4985 #[inline(always)]
4986 fn new_empty() -> Self {
4987 Self { player_id: fidl::new_empty!(u16, D) }
4988 }
4989
4990 #[inline]
4991 unsafe fn decode(
4992 &mut self,
4993 decoder: &mut fidl::encoding::Decoder<'_, D>,
4994 offset: usize,
4995 _depth: fidl::encoding::Depth,
4996 ) -> fidl::Result<()> {
4997 decoder.debug_check_bounds::<Self>(offset);
4998 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
4999 unsafe {
5002 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
5003 }
5004 Ok(())
5005 }
5006 }
5007
5008 impl fidl::encoding::ValueTypeMarker for ControllerSetNotificationFilterRequest {
5009 type Borrowed<'a> = &'a Self;
5010 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5011 value
5012 }
5013 }
5014
5015 unsafe impl fidl::encoding::TypeMarker for ControllerSetNotificationFilterRequest {
5016 type Owned = Self;
5017
5018 #[inline(always)]
5019 fn inline_align(_context: fidl::encoding::Context) -> usize {
5020 4
5021 }
5022
5023 #[inline(always)]
5024 fn inline_size(_context: fidl::encoding::Context) -> usize {
5025 8
5026 }
5027 }
5028
5029 unsafe impl<D: fidl::encoding::ResourceDialect>
5030 fidl::encoding::Encode<ControllerSetNotificationFilterRequest, D>
5031 for &ControllerSetNotificationFilterRequest
5032 {
5033 #[inline]
5034 unsafe fn encode(
5035 self,
5036 encoder: &mut fidl::encoding::Encoder<'_, D>,
5037 offset: usize,
5038 _depth: fidl::encoding::Depth,
5039 ) -> fidl::Result<()> {
5040 encoder.debug_check_bounds::<ControllerSetNotificationFilterRequest>(offset);
5041 fidl::encoding::Encode::<ControllerSetNotificationFilterRequest, D>::encode(
5043 (
5044 <Notifications as fidl::encoding::ValueTypeMarker>::borrow(&self.notifications),
5045 <u32 as fidl::encoding::ValueTypeMarker>::borrow(
5046 &self.position_change_interval,
5047 ),
5048 ),
5049 encoder,
5050 offset,
5051 _depth,
5052 )
5053 }
5054 }
5055 unsafe impl<
5056 D: fidl::encoding::ResourceDialect,
5057 T0: fidl::encoding::Encode<Notifications, D>,
5058 T1: fidl::encoding::Encode<u32, D>,
5059 > fidl::encoding::Encode<ControllerSetNotificationFilterRequest, D> for (T0, T1)
5060 {
5061 #[inline]
5062 unsafe fn encode(
5063 self,
5064 encoder: &mut fidl::encoding::Encoder<'_, D>,
5065 offset: usize,
5066 depth: fidl::encoding::Depth,
5067 ) -> fidl::Result<()> {
5068 encoder.debug_check_bounds::<ControllerSetNotificationFilterRequest>(offset);
5069 self.0.encode(encoder, offset + 0, depth)?;
5073 self.1.encode(encoder, offset + 4, depth)?;
5074 Ok(())
5075 }
5076 }
5077
5078 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5079 for ControllerSetNotificationFilterRequest
5080 {
5081 #[inline(always)]
5082 fn new_empty() -> Self {
5083 Self {
5084 notifications: fidl::new_empty!(Notifications, D),
5085 position_change_interval: fidl::new_empty!(u32, D),
5086 }
5087 }
5088
5089 #[inline]
5090 unsafe fn decode(
5091 &mut self,
5092 decoder: &mut fidl::encoding::Decoder<'_, D>,
5093 offset: usize,
5094 _depth: fidl::encoding::Depth,
5095 ) -> fidl::Result<()> {
5096 decoder.debug_check_bounds::<Self>(offset);
5097 fidl::decode!(Notifications, D, &mut self.notifications, decoder, offset + 0, _depth)?;
5099 fidl::decode!(u32, D, &mut self.position_change_interval, decoder, offset + 4, _depth)?;
5100 Ok(())
5101 }
5102 }
5103
5104 impl fidl::encoding::ValueTypeMarker for ControllerSetPlayerApplicationSettingsRequest {
5105 type Borrowed<'a> = &'a Self;
5106 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5107 value
5108 }
5109 }
5110
5111 unsafe impl fidl::encoding::TypeMarker for ControllerSetPlayerApplicationSettingsRequest {
5112 type Owned = Self;
5113
5114 #[inline(always)]
5115 fn inline_align(_context: fidl::encoding::Context) -> usize {
5116 8
5117 }
5118
5119 #[inline(always)]
5120 fn inline_size(_context: fidl::encoding::Context) -> usize {
5121 16
5122 }
5123 }
5124
5125 unsafe impl<D: fidl::encoding::ResourceDialect>
5126 fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsRequest, D>
5127 for &ControllerSetPlayerApplicationSettingsRequest
5128 {
5129 #[inline]
5130 unsafe fn encode(
5131 self,
5132 encoder: &mut fidl::encoding::Encoder<'_, D>,
5133 offset: usize,
5134 _depth: fidl::encoding::Depth,
5135 ) -> fidl::Result<()> {
5136 encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsRequest>(offset);
5137 fidl::encoding::Encode::<ControllerSetPlayerApplicationSettingsRequest, D>::encode(
5139 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5140 &self.requested_settings,
5141 ),),
5142 encoder,
5143 offset,
5144 _depth,
5145 )
5146 }
5147 }
5148 unsafe impl<
5149 D: fidl::encoding::ResourceDialect,
5150 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5151 > fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsRequest, D> for (T0,)
5152 {
5153 #[inline]
5154 unsafe fn encode(
5155 self,
5156 encoder: &mut fidl::encoding::Encoder<'_, D>,
5157 offset: usize,
5158 depth: fidl::encoding::Depth,
5159 ) -> fidl::Result<()> {
5160 encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsRequest>(offset);
5161 self.0.encode(encoder, offset + 0, depth)?;
5165 Ok(())
5166 }
5167 }
5168
5169 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5170 for ControllerSetPlayerApplicationSettingsRequest
5171 {
5172 #[inline(always)]
5173 fn new_empty() -> Self {
5174 Self { requested_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5175 }
5176
5177 #[inline]
5178 unsafe fn decode(
5179 &mut self,
5180 decoder: &mut fidl::encoding::Decoder<'_, D>,
5181 offset: usize,
5182 _depth: fidl::encoding::Depth,
5183 ) -> fidl::Result<()> {
5184 decoder.debug_check_bounds::<Self>(offset);
5185 fidl::decode!(
5187 PlayerApplicationSettings,
5188 D,
5189 &mut self.requested_settings,
5190 decoder,
5191 offset + 0,
5192 _depth
5193 )?;
5194 Ok(())
5195 }
5196 }
5197
5198 impl fidl::encoding::ValueTypeMarker for ControllerGetMediaAttributesResponse {
5199 type Borrowed<'a> = &'a Self;
5200 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5201 value
5202 }
5203 }
5204
5205 unsafe impl fidl::encoding::TypeMarker for ControllerGetMediaAttributesResponse {
5206 type Owned = Self;
5207
5208 #[inline(always)]
5209 fn inline_align(_context: fidl::encoding::Context) -> usize {
5210 8
5211 }
5212
5213 #[inline(always)]
5214 fn inline_size(_context: fidl::encoding::Context) -> usize {
5215 16
5216 }
5217 }
5218
5219 unsafe impl<D: fidl::encoding::ResourceDialect>
5220 fidl::encoding::Encode<ControllerGetMediaAttributesResponse, D>
5221 for &ControllerGetMediaAttributesResponse
5222 {
5223 #[inline]
5224 unsafe fn encode(
5225 self,
5226 encoder: &mut fidl::encoding::Encoder<'_, D>,
5227 offset: usize,
5228 _depth: fidl::encoding::Depth,
5229 ) -> fidl::Result<()> {
5230 encoder.debug_check_bounds::<ControllerGetMediaAttributesResponse>(offset);
5231 fidl::encoding::Encode::<ControllerGetMediaAttributesResponse, D>::encode(
5233 (<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),),
5234 encoder,
5235 offset,
5236 _depth,
5237 )
5238 }
5239 }
5240 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MediaAttributes, D>>
5241 fidl::encoding::Encode<ControllerGetMediaAttributesResponse, D> for (T0,)
5242 {
5243 #[inline]
5244 unsafe fn encode(
5245 self,
5246 encoder: &mut fidl::encoding::Encoder<'_, D>,
5247 offset: usize,
5248 depth: fidl::encoding::Depth,
5249 ) -> fidl::Result<()> {
5250 encoder.debug_check_bounds::<ControllerGetMediaAttributesResponse>(offset);
5251 self.0.encode(encoder, offset + 0, depth)?;
5255 Ok(())
5256 }
5257 }
5258
5259 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5260 for ControllerGetMediaAttributesResponse
5261 {
5262 #[inline(always)]
5263 fn new_empty() -> Self {
5264 Self { attributes: fidl::new_empty!(MediaAttributes, D) }
5265 }
5266
5267 #[inline]
5268 unsafe fn decode(
5269 &mut self,
5270 decoder: &mut fidl::encoding::Decoder<'_, D>,
5271 offset: usize,
5272 _depth: fidl::encoding::Depth,
5273 ) -> fidl::Result<()> {
5274 decoder.debug_check_bounds::<Self>(offset);
5275 fidl::decode!(MediaAttributes, D, &mut self.attributes, decoder, offset + 0, _depth)?;
5277 Ok(())
5278 }
5279 }
5280
5281 impl fidl::encoding::ValueTypeMarker for ControllerGetPlayStatusResponse {
5282 type Borrowed<'a> = &'a Self;
5283 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5284 value
5285 }
5286 }
5287
5288 unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayStatusResponse {
5289 type Owned = Self;
5290
5291 #[inline(always)]
5292 fn inline_align(_context: fidl::encoding::Context) -> usize {
5293 8
5294 }
5295
5296 #[inline(always)]
5297 fn inline_size(_context: fidl::encoding::Context) -> usize {
5298 16
5299 }
5300 }
5301
5302 unsafe impl<D: fidl::encoding::ResourceDialect>
5303 fidl::encoding::Encode<ControllerGetPlayStatusResponse, D>
5304 for &ControllerGetPlayStatusResponse
5305 {
5306 #[inline]
5307 unsafe fn encode(
5308 self,
5309 encoder: &mut fidl::encoding::Encoder<'_, D>,
5310 offset: usize,
5311 _depth: fidl::encoding::Depth,
5312 ) -> fidl::Result<()> {
5313 encoder.debug_check_bounds::<ControllerGetPlayStatusResponse>(offset);
5314 fidl::encoding::Encode::<ControllerGetPlayStatusResponse, D>::encode(
5316 (<PlayStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.play_status),),
5317 encoder,
5318 offset,
5319 _depth,
5320 )
5321 }
5322 }
5323 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PlayStatus, D>>
5324 fidl::encoding::Encode<ControllerGetPlayStatusResponse, D> for (T0,)
5325 {
5326 #[inline]
5327 unsafe fn encode(
5328 self,
5329 encoder: &mut fidl::encoding::Encoder<'_, D>,
5330 offset: usize,
5331 depth: fidl::encoding::Depth,
5332 ) -> fidl::Result<()> {
5333 encoder.debug_check_bounds::<ControllerGetPlayStatusResponse>(offset);
5334 self.0.encode(encoder, offset + 0, depth)?;
5338 Ok(())
5339 }
5340 }
5341
5342 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5343 for ControllerGetPlayStatusResponse
5344 {
5345 #[inline(always)]
5346 fn new_empty() -> Self {
5347 Self { play_status: fidl::new_empty!(PlayStatus, D) }
5348 }
5349
5350 #[inline]
5351 unsafe fn decode(
5352 &mut self,
5353 decoder: &mut fidl::encoding::Decoder<'_, D>,
5354 offset: usize,
5355 _depth: fidl::encoding::Depth,
5356 ) -> fidl::Result<()> {
5357 decoder.debug_check_bounds::<Self>(offset);
5358 fidl::decode!(PlayStatus, D, &mut self.play_status, decoder, offset + 0, _depth)?;
5360 Ok(())
5361 }
5362 }
5363
5364 impl fidl::encoding::ValueTypeMarker for ControllerGetPlayerApplicationSettingsResponse {
5365 type Borrowed<'a> = &'a Self;
5366 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5367 value
5368 }
5369 }
5370
5371 unsafe impl fidl::encoding::TypeMarker for ControllerGetPlayerApplicationSettingsResponse {
5372 type Owned = Self;
5373
5374 #[inline(always)]
5375 fn inline_align(_context: fidl::encoding::Context) -> usize {
5376 8
5377 }
5378
5379 #[inline(always)]
5380 fn inline_size(_context: fidl::encoding::Context) -> usize {
5381 16
5382 }
5383 }
5384
5385 unsafe impl<D: fidl::encoding::ResourceDialect>
5386 fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsResponse, D>
5387 for &ControllerGetPlayerApplicationSettingsResponse
5388 {
5389 #[inline]
5390 unsafe fn encode(
5391 self,
5392 encoder: &mut fidl::encoding::Encoder<'_, D>,
5393 offset: usize,
5394 _depth: fidl::encoding::Depth,
5395 ) -> fidl::Result<()> {
5396 encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsResponse>(offset);
5397 fidl::encoding::Encode::<ControllerGetPlayerApplicationSettingsResponse, D>::encode(
5399 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5400 &self.current_settings,
5401 ),),
5402 encoder,
5403 offset,
5404 _depth,
5405 )
5406 }
5407 }
5408 unsafe impl<
5409 D: fidl::encoding::ResourceDialect,
5410 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5411 > fidl::encoding::Encode<ControllerGetPlayerApplicationSettingsResponse, D> for (T0,)
5412 {
5413 #[inline]
5414 unsafe fn encode(
5415 self,
5416 encoder: &mut fidl::encoding::Encoder<'_, D>,
5417 offset: usize,
5418 depth: fidl::encoding::Depth,
5419 ) -> fidl::Result<()> {
5420 encoder.debug_check_bounds::<ControllerGetPlayerApplicationSettingsResponse>(offset);
5421 self.0.encode(encoder, offset + 0, depth)?;
5425 Ok(())
5426 }
5427 }
5428
5429 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5430 for ControllerGetPlayerApplicationSettingsResponse
5431 {
5432 #[inline(always)]
5433 fn new_empty() -> Self {
5434 Self { current_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5435 }
5436
5437 #[inline]
5438 unsafe fn decode(
5439 &mut self,
5440 decoder: &mut fidl::encoding::Decoder<'_, D>,
5441 offset: usize,
5442 _depth: fidl::encoding::Depth,
5443 ) -> fidl::Result<()> {
5444 decoder.debug_check_bounds::<Self>(offset);
5445 fidl::decode!(
5447 PlayerApplicationSettings,
5448 D,
5449 &mut self.current_settings,
5450 decoder,
5451 offset + 0,
5452 _depth
5453 )?;
5454 Ok(())
5455 }
5456 }
5457
5458 impl fidl::encoding::ValueTypeMarker for ControllerSetAbsoluteVolumeResponse {
5459 type Borrowed<'a> = &'a Self;
5460 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5461 value
5462 }
5463 }
5464
5465 unsafe impl fidl::encoding::TypeMarker for ControllerSetAbsoluteVolumeResponse {
5466 type Owned = Self;
5467
5468 #[inline(always)]
5469 fn inline_align(_context: fidl::encoding::Context) -> usize {
5470 1
5471 }
5472
5473 #[inline(always)]
5474 fn inline_size(_context: fidl::encoding::Context) -> usize {
5475 1
5476 }
5477 #[inline(always)]
5478 fn encode_is_copy() -> bool {
5479 true
5480 }
5481
5482 #[inline(always)]
5483 fn decode_is_copy() -> bool {
5484 true
5485 }
5486 }
5487
5488 unsafe impl<D: fidl::encoding::ResourceDialect>
5489 fidl::encoding::Encode<ControllerSetAbsoluteVolumeResponse, D>
5490 for &ControllerSetAbsoluteVolumeResponse
5491 {
5492 #[inline]
5493 unsafe fn encode(
5494 self,
5495 encoder: &mut fidl::encoding::Encoder<'_, D>,
5496 offset: usize,
5497 _depth: fidl::encoding::Depth,
5498 ) -> fidl::Result<()> {
5499 encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeResponse>(offset);
5500 unsafe {
5501 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
5503 (buf_ptr as *mut ControllerSetAbsoluteVolumeResponse)
5504 .write_unaligned((self as *const ControllerSetAbsoluteVolumeResponse).read());
5505 }
5508 Ok(())
5509 }
5510 }
5511 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u8, D>>
5512 fidl::encoding::Encode<ControllerSetAbsoluteVolumeResponse, D> for (T0,)
5513 {
5514 #[inline]
5515 unsafe fn encode(
5516 self,
5517 encoder: &mut fidl::encoding::Encoder<'_, D>,
5518 offset: usize,
5519 depth: fidl::encoding::Depth,
5520 ) -> fidl::Result<()> {
5521 encoder.debug_check_bounds::<ControllerSetAbsoluteVolumeResponse>(offset);
5522 self.0.encode(encoder, offset + 0, depth)?;
5526 Ok(())
5527 }
5528 }
5529
5530 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5531 for ControllerSetAbsoluteVolumeResponse
5532 {
5533 #[inline(always)]
5534 fn new_empty() -> Self {
5535 Self { set_volume: fidl::new_empty!(u8, D) }
5536 }
5537
5538 #[inline]
5539 unsafe fn decode(
5540 &mut self,
5541 decoder: &mut fidl::encoding::Decoder<'_, D>,
5542 offset: usize,
5543 _depth: fidl::encoding::Depth,
5544 ) -> fidl::Result<()> {
5545 decoder.debug_check_bounds::<Self>(offset);
5546 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
5547 unsafe {
5550 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 1);
5551 }
5552 Ok(())
5553 }
5554 }
5555
5556 impl fidl::encoding::ValueTypeMarker for ControllerSetPlayerApplicationSettingsResponse {
5557 type Borrowed<'a> = &'a Self;
5558 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5559 value
5560 }
5561 }
5562
5563 unsafe impl fidl::encoding::TypeMarker for ControllerSetPlayerApplicationSettingsResponse {
5564 type Owned = Self;
5565
5566 #[inline(always)]
5567 fn inline_align(_context: fidl::encoding::Context) -> usize {
5568 8
5569 }
5570
5571 #[inline(always)]
5572 fn inline_size(_context: fidl::encoding::Context) -> usize {
5573 16
5574 }
5575 }
5576
5577 unsafe impl<D: fidl::encoding::ResourceDialect>
5578 fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsResponse, D>
5579 for &ControllerSetPlayerApplicationSettingsResponse
5580 {
5581 #[inline]
5582 unsafe fn encode(
5583 self,
5584 encoder: &mut fidl::encoding::Encoder<'_, D>,
5585 offset: usize,
5586 _depth: fidl::encoding::Depth,
5587 ) -> fidl::Result<()> {
5588 encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsResponse>(offset);
5589 fidl::encoding::Encode::<ControllerSetPlayerApplicationSettingsResponse, D>::encode(
5591 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
5592 &self.set_settings,
5593 ),),
5594 encoder,
5595 offset,
5596 _depth,
5597 )
5598 }
5599 }
5600 unsafe impl<
5601 D: fidl::encoding::ResourceDialect,
5602 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
5603 > fidl::encoding::Encode<ControllerSetPlayerApplicationSettingsResponse, D> for (T0,)
5604 {
5605 #[inline]
5606 unsafe fn encode(
5607 self,
5608 encoder: &mut fidl::encoding::Encoder<'_, D>,
5609 offset: usize,
5610 depth: fidl::encoding::Depth,
5611 ) -> fidl::Result<()> {
5612 encoder.debug_check_bounds::<ControllerSetPlayerApplicationSettingsResponse>(offset);
5613 self.0.encode(encoder, offset + 0, depth)?;
5617 Ok(())
5618 }
5619 }
5620
5621 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5622 for ControllerSetPlayerApplicationSettingsResponse
5623 {
5624 #[inline(always)]
5625 fn new_empty() -> Self {
5626 Self { set_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
5627 }
5628
5629 #[inline]
5630 unsafe fn decode(
5631 &mut self,
5632 decoder: &mut fidl::encoding::Decoder<'_, D>,
5633 offset: usize,
5634 _depth: fidl::encoding::Depth,
5635 ) -> fidl::Result<()> {
5636 decoder.debug_check_bounds::<Self>(offset);
5637 fidl::decode!(
5639 PlayerApplicationSettings,
5640 D,
5641 &mut self.set_settings,
5642 decoder,
5643 offset + 0,
5644 _depth
5645 )?;
5646 Ok(())
5647 }
5648 }
5649
5650 impl fidl::encoding::ValueTypeMarker for CustomAttributeValue {
5651 type Borrowed<'a> = &'a Self;
5652 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5653 value
5654 }
5655 }
5656
5657 unsafe impl fidl::encoding::TypeMarker for CustomAttributeValue {
5658 type Owned = Self;
5659
5660 #[inline(always)]
5661 fn inline_align(_context: fidl::encoding::Context) -> usize {
5662 8
5663 }
5664
5665 #[inline(always)]
5666 fn inline_size(_context: fidl::encoding::Context) -> usize {
5667 24
5668 }
5669 }
5670
5671 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CustomAttributeValue, D>
5672 for &CustomAttributeValue
5673 {
5674 #[inline]
5675 unsafe fn encode(
5676 self,
5677 encoder: &mut fidl::encoding::Encoder<'_, D>,
5678 offset: usize,
5679 _depth: fidl::encoding::Depth,
5680 ) -> fidl::Result<()> {
5681 encoder.debug_check_bounds::<CustomAttributeValue>(offset);
5682 fidl::encoding::Encode::<CustomAttributeValue, D>::encode(
5684 (
5685 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(
5686 &self.description,
5687 ),
5688 <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.value),
5689 ),
5690 encoder,
5691 offset,
5692 _depth,
5693 )
5694 }
5695 }
5696 unsafe impl<
5697 D: fidl::encoding::ResourceDialect,
5698 T0: fidl::encoding::Encode<fidl::encoding::BoundedString<255>, D>,
5699 T1: fidl::encoding::Encode<u8, D>,
5700 > fidl::encoding::Encode<CustomAttributeValue, D> for (T0, T1)
5701 {
5702 #[inline]
5703 unsafe fn encode(
5704 self,
5705 encoder: &mut fidl::encoding::Encoder<'_, D>,
5706 offset: usize,
5707 depth: fidl::encoding::Depth,
5708 ) -> fidl::Result<()> {
5709 encoder.debug_check_bounds::<CustomAttributeValue>(offset);
5710 unsafe {
5713 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
5714 (ptr as *mut u64).write_unaligned(0);
5715 }
5716 self.0.encode(encoder, offset + 0, depth)?;
5718 self.1.encode(encoder, offset + 16, depth)?;
5719 Ok(())
5720 }
5721 }
5722
5723 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CustomAttributeValue {
5724 #[inline(always)]
5725 fn new_empty() -> Self {
5726 Self {
5727 description: fidl::new_empty!(fidl::encoding::BoundedString<255>, D),
5728 value: fidl::new_empty!(u8, D),
5729 }
5730 }
5731
5732 #[inline]
5733 unsafe fn decode(
5734 &mut self,
5735 decoder: &mut fidl::encoding::Decoder<'_, D>,
5736 offset: usize,
5737 _depth: fidl::encoding::Depth,
5738 ) -> fidl::Result<()> {
5739 decoder.debug_check_bounds::<Self>(offset);
5740 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
5742 let padval = unsafe { (ptr as *const u64).read_unaligned() };
5743 let mask = 0xffffffffffffff00u64;
5744 let maskedval = padval & mask;
5745 if maskedval != 0 {
5746 return Err(fidl::Error::NonZeroPadding {
5747 padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
5748 });
5749 }
5750 fidl::decode!(
5751 fidl::encoding::BoundedString<255>,
5752 D,
5753 &mut self.description,
5754 decoder,
5755 offset + 0,
5756 _depth
5757 )?;
5758 fidl::decode!(u8, D, &mut self.value, decoder, offset + 16, _depth)?;
5759 Ok(())
5760 }
5761 }
5762
5763 impl fidl::encoding::ValueTypeMarker for Parent {
5764 type Borrowed<'a> = &'a Self;
5765 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5766 value
5767 }
5768 }
5769
5770 unsafe impl fidl::encoding::TypeMarker for Parent {
5771 type Owned = Self;
5772
5773 #[inline(always)]
5774 fn inline_align(_context: fidl::encoding::Context) -> usize {
5775 1
5776 }
5777
5778 #[inline(always)]
5779 fn inline_size(_context: fidl::encoding::Context) -> usize {
5780 1
5781 }
5782 }
5783
5784 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parent, D> for &Parent {
5785 #[inline]
5786 unsafe fn encode(
5787 self,
5788 encoder: &mut fidl::encoding::Encoder<'_, D>,
5789 offset: usize,
5790 _depth: fidl::encoding::Depth,
5791 ) -> fidl::Result<()> {
5792 encoder.debug_check_bounds::<Parent>(offset);
5793 encoder.write_num(0u8, offset);
5794 Ok(())
5795 }
5796 }
5797
5798 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parent {
5799 #[inline(always)]
5800 fn new_empty() -> Self {
5801 Self
5802 }
5803
5804 #[inline]
5805 unsafe fn decode(
5806 &mut self,
5807 decoder: &mut fidl::encoding::Decoder<'_, D>,
5808 offset: usize,
5809 _depth: fidl::encoding::Depth,
5810 ) -> fidl::Result<()> {
5811 decoder.debug_check_bounds::<Self>(offset);
5812 match decoder.read_num::<u8>(offset) {
5813 0 => Ok(()),
5814 _ => Err(fidl::Error::Invalid),
5815 }
5816 }
5817 }
5818
5819 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetNotificationRequest {
5820 type Borrowed<'a> = &'a Self;
5821 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5822 value
5823 }
5824 }
5825
5826 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetNotificationRequest {
5827 type Owned = Self;
5828
5829 #[inline(always)]
5830 fn inline_align(_context: fidl::encoding::Context) -> usize {
5831 1
5832 }
5833
5834 #[inline(always)]
5835 fn inline_size(_context: fidl::encoding::Context) -> usize {
5836 1
5837 }
5838 }
5839
5840 unsafe impl<D: fidl::encoding::ResourceDialect>
5841 fidl::encoding::Encode<TargetHandlerGetNotificationRequest, D>
5842 for &TargetHandlerGetNotificationRequest
5843 {
5844 #[inline]
5845 unsafe fn encode(
5846 self,
5847 encoder: &mut fidl::encoding::Encoder<'_, D>,
5848 offset: usize,
5849 _depth: fidl::encoding::Depth,
5850 ) -> fidl::Result<()> {
5851 encoder.debug_check_bounds::<TargetHandlerGetNotificationRequest>(offset);
5852 fidl::encoding::Encode::<TargetHandlerGetNotificationRequest, D>::encode(
5854 (<NotificationEvent as fidl::encoding::ValueTypeMarker>::borrow(&self.event_id),),
5855 encoder,
5856 offset,
5857 _depth,
5858 )
5859 }
5860 }
5861 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<NotificationEvent, D>>
5862 fidl::encoding::Encode<TargetHandlerGetNotificationRequest, D> for (T0,)
5863 {
5864 #[inline]
5865 unsafe fn encode(
5866 self,
5867 encoder: &mut fidl::encoding::Encoder<'_, D>,
5868 offset: usize,
5869 depth: fidl::encoding::Depth,
5870 ) -> fidl::Result<()> {
5871 encoder.debug_check_bounds::<TargetHandlerGetNotificationRequest>(offset);
5872 self.0.encode(encoder, offset + 0, depth)?;
5876 Ok(())
5877 }
5878 }
5879
5880 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5881 for TargetHandlerGetNotificationRequest
5882 {
5883 #[inline(always)]
5884 fn new_empty() -> Self {
5885 Self { event_id: fidl::new_empty!(NotificationEvent, D) }
5886 }
5887
5888 #[inline]
5889 unsafe fn decode(
5890 &mut self,
5891 decoder: &mut fidl::encoding::Decoder<'_, D>,
5892 offset: usize,
5893 _depth: fidl::encoding::Depth,
5894 ) -> fidl::Result<()> {
5895 decoder.debug_check_bounds::<Self>(offset);
5896 fidl::decode!(NotificationEvent, D, &mut self.event_id, decoder, offset + 0, _depth)?;
5898 Ok(())
5899 }
5900 }
5901
5902 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayerApplicationSettingsRequest {
5903 type Borrowed<'a> = &'a Self;
5904 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5905 value
5906 }
5907 }
5908
5909 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayerApplicationSettingsRequest {
5910 type Owned = Self;
5911
5912 #[inline(always)]
5913 fn inline_align(_context: fidl::encoding::Context) -> usize {
5914 8
5915 }
5916
5917 #[inline(always)]
5918 fn inline_size(_context: fidl::encoding::Context) -> usize {
5919 16
5920 }
5921 }
5922
5923 unsafe impl<D: fidl::encoding::ResourceDialect>
5924 fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsRequest, D>
5925 for &TargetHandlerGetPlayerApplicationSettingsRequest
5926 {
5927 #[inline]
5928 unsafe fn encode(
5929 self,
5930 encoder: &mut fidl::encoding::Encoder<'_, D>,
5931 offset: usize,
5932 _depth: fidl::encoding::Depth,
5933 ) -> fidl::Result<()> {
5934 encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsRequest>(offset);
5935 fidl::encoding::Encode::<TargetHandlerGetPlayerApplicationSettingsRequest, D>::encode(
5937 (
5938 <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attribute_ids),
5939 ),
5940 encoder, offset, _depth
5941 )
5942 }
5943 }
5944 unsafe impl<
5945 D: fidl::encoding::ResourceDialect,
5946 T0: fidl::encoding::Encode<
5947 fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
5948 D,
5949 >,
5950 > fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsRequest, D> for (T0,)
5951 {
5952 #[inline]
5953 unsafe fn encode(
5954 self,
5955 encoder: &mut fidl::encoding::Encoder<'_, D>,
5956 offset: usize,
5957 depth: fidl::encoding::Depth,
5958 ) -> fidl::Result<()> {
5959 encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsRequest>(offset);
5960 self.0.encode(encoder, offset + 0, depth)?;
5964 Ok(())
5965 }
5966 }
5967
5968 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5969 for TargetHandlerGetPlayerApplicationSettingsRequest
5970 {
5971 #[inline(always)]
5972 fn new_empty() -> Self {
5973 Self {
5974 attribute_ids: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
5975 }
5976 }
5977
5978 #[inline]
5979 unsafe fn decode(
5980 &mut self,
5981 decoder: &mut fidl::encoding::Decoder<'_, D>,
5982 offset: usize,
5983 _depth: fidl::encoding::Depth,
5984 ) -> fidl::Result<()> {
5985 decoder.debug_check_bounds::<Self>(offset);
5986 fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attribute_ids, decoder, offset + 0, _depth)?;
5988 Ok(())
5989 }
5990 }
5991
5992 impl fidl::encoding::ValueTypeMarker for TargetHandlerSendCommandRequest {
5993 type Borrowed<'a> = &'a Self;
5994 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5995 value
5996 }
5997 }
5998
5999 unsafe impl fidl::encoding::TypeMarker for TargetHandlerSendCommandRequest {
6000 type Owned = Self;
6001
6002 #[inline(always)]
6003 fn inline_align(_context: fidl::encoding::Context) -> usize {
6004 1
6005 }
6006
6007 #[inline(always)]
6008 fn inline_size(_context: fidl::encoding::Context) -> usize {
6009 2
6010 }
6011 }
6012
6013 unsafe impl<D: fidl::encoding::ResourceDialect>
6014 fidl::encoding::Encode<TargetHandlerSendCommandRequest, D>
6015 for &TargetHandlerSendCommandRequest
6016 {
6017 #[inline]
6018 unsafe fn encode(
6019 self,
6020 encoder: &mut fidl::encoding::Encoder<'_, D>,
6021 offset: usize,
6022 _depth: fidl::encoding::Depth,
6023 ) -> fidl::Result<()> {
6024 encoder.debug_check_bounds::<TargetHandlerSendCommandRequest>(offset);
6025 fidl::encoding::Encode::<TargetHandlerSendCommandRequest, D>::encode(
6027 (
6028 <AvcPanelCommand as fidl::encoding::ValueTypeMarker>::borrow(&self.command),
6029 <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.pressed),
6030 ),
6031 encoder,
6032 offset,
6033 _depth,
6034 )
6035 }
6036 }
6037 unsafe impl<
6038 D: fidl::encoding::ResourceDialect,
6039 T0: fidl::encoding::Encode<AvcPanelCommand, D>,
6040 T1: fidl::encoding::Encode<bool, D>,
6041 > fidl::encoding::Encode<TargetHandlerSendCommandRequest, D> for (T0, T1)
6042 {
6043 #[inline]
6044 unsafe fn encode(
6045 self,
6046 encoder: &mut fidl::encoding::Encoder<'_, D>,
6047 offset: usize,
6048 depth: fidl::encoding::Depth,
6049 ) -> fidl::Result<()> {
6050 encoder.debug_check_bounds::<TargetHandlerSendCommandRequest>(offset);
6051 self.0.encode(encoder, offset + 0, depth)?;
6055 self.1.encode(encoder, offset + 1, depth)?;
6056 Ok(())
6057 }
6058 }
6059
6060 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6061 for TargetHandlerSendCommandRequest
6062 {
6063 #[inline(always)]
6064 fn new_empty() -> Self {
6065 Self {
6066 command: fidl::new_empty!(AvcPanelCommand, D),
6067 pressed: fidl::new_empty!(bool, D),
6068 }
6069 }
6070
6071 #[inline]
6072 unsafe fn decode(
6073 &mut self,
6074 decoder: &mut fidl::encoding::Decoder<'_, D>,
6075 offset: usize,
6076 _depth: fidl::encoding::Depth,
6077 ) -> fidl::Result<()> {
6078 decoder.debug_check_bounds::<Self>(offset);
6079 fidl::decode!(AvcPanelCommand, D, &mut self.command, decoder, offset + 0, _depth)?;
6081 fidl::decode!(bool, D, &mut self.pressed, decoder, offset + 1, _depth)?;
6082 Ok(())
6083 }
6084 }
6085
6086 impl fidl::encoding::ValueTypeMarker for TargetHandlerSetAddressedPlayerRequest {
6087 type Borrowed<'a> = &'a Self;
6088 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6089 value
6090 }
6091 }
6092
6093 unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetAddressedPlayerRequest {
6094 type Owned = Self;
6095
6096 #[inline(always)]
6097 fn inline_align(_context: fidl::encoding::Context) -> usize {
6098 2
6099 }
6100
6101 #[inline(always)]
6102 fn inline_size(_context: fidl::encoding::Context) -> usize {
6103 2
6104 }
6105 #[inline(always)]
6106 fn encode_is_copy() -> bool {
6107 true
6108 }
6109
6110 #[inline(always)]
6111 fn decode_is_copy() -> bool {
6112 true
6113 }
6114 }
6115
6116 unsafe impl<D: fidl::encoding::ResourceDialect>
6117 fidl::encoding::Encode<TargetHandlerSetAddressedPlayerRequest, D>
6118 for &TargetHandlerSetAddressedPlayerRequest
6119 {
6120 #[inline]
6121 unsafe fn encode(
6122 self,
6123 encoder: &mut fidl::encoding::Encoder<'_, D>,
6124 offset: usize,
6125 _depth: fidl::encoding::Depth,
6126 ) -> fidl::Result<()> {
6127 encoder.debug_check_bounds::<TargetHandlerSetAddressedPlayerRequest>(offset);
6128 unsafe {
6129 let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
6131 (buf_ptr as *mut TargetHandlerSetAddressedPlayerRequest).write_unaligned(
6132 (self as *const TargetHandlerSetAddressedPlayerRequest).read(),
6133 );
6134 }
6137 Ok(())
6138 }
6139 }
6140 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AddressedPlayerId, D>>
6141 fidl::encoding::Encode<TargetHandlerSetAddressedPlayerRequest, D> for (T0,)
6142 {
6143 #[inline]
6144 unsafe fn encode(
6145 self,
6146 encoder: &mut fidl::encoding::Encoder<'_, D>,
6147 offset: usize,
6148 depth: fidl::encoding::Depth,
6149 ) -> fidl::Result<()> {
6150 encoder.debug_check_bounds::<TargetHandlerSetAddressedPlayerRequest>(offset);
6151 self.0.encode(encoder, offset + 0, depth)?;
6155 Ok(())
6156 }
6157 }
6158
6159 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6160 for TargetHandlerSetAddressedPlayerRequest
6161 {
6162 #[inline(always)]
6163 fn new_empty() -> Self {
6164 Self { player_id: fidl::new_empty!(AddressedPlayerId, D) }
6165 }
6166
6167 #[inline]
6168 unsafe fn decode(
6169 &mut self,
6170 decoder: &mut fidl::encoding::Decoder<'_, D>,
6171 offset: usize,
6172 _depth: fidl::encoding::Depth,
6173 ) -> fidl::Result<()> {
6174 decoder.debug_check_bounds::<Self>(offset);
6175 let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
6176 unsafe {
6179 std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
6180 }
6181 Ok(())
6182 }
6183 }
6184
6185 impl fidl::encoding::ValueTypeMarker for TargetHandlerSetPlayerApplicationSettingsRequest {
6186 type Borrowed<'a> = &'a Self;
6187 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6188 value
6189 }
6190 }
6191
6192 unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetPlayerApplicationSettingsRequest {
6193 type Owned = Self;
6194
6195 #[inline(always)]
6196 fn inline_align(_context: fidl::encoding::Context) -> usize {
6197 8
6198 }
6199
6200 #[inline(always)]
6201 fn inline_size(_context: fidl::encoding::Context) -> usize {
6202 16
6203 }
6204 }
6205
6206 unsafe impl<D: fidl::encoding::ResourceDialect>
6207 fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsRequest, D>
6208 for &TargetHandlerSetPlayerApplicationSettingsRequest
6209 {
6210 #[inline]
6211 unsafe fn encode(
6212 self,
6213 encoder: &mut fidl::encoding::Encoder<'_, D>,
6214 offset: usize,
6215 _depth: fidl::encoding::Depth,
6216 ) -> fidl::Result<()> {
6217 encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsRequest>(offset);
6218 fidl::encoding::Encode::<TargetHandlerSetPlayerApplicationSettingsRequest, D>::encode(
6220 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
6221 &self.requested_settings,
6222 ),),
6223 encoder,
6224 offset,
6225 _depth,
6226 )
6227 }
6228 }
6229 unsafe impl<
6230 D: fidl::encoding::ResourceDialect,
6231 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
6232 > fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsRequest, D> for (T0,)
6233 {
6234 #[inline]
6235 unsafe fn encode(
6236 self,
6237 encoder: &mut fidl::encoding::Encoder<'_, D>,
6238 offset: usize,
6239 depth: fidl::encoding::Depth,
6240 ) -> fidl::Result<()> {
6241 encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsRequest>(offset);
6242 self.0.encode(encoder, offset + 0, depth)?;
6246 Ok(())
6247 }
6248 }
6249
6250 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6251 for TargetHandlerSetPlayerApplicationSettingsRequest
6252 {
6253 #[inline(always)]
6254 fn new_empty() -> Self {
6255 Self { requested_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
6256 }
6257
6258 #[inline]
6259 unsafe fn decode(
6260 &mut self,
6261 decoder: &mut fidl::encoding::Decoder<'_, D>,
6262 offset: usize,
6263 _depth: fidl::encoding::Depth,
6264 ) -> fidl::Result<()> {
6265 decoder.debug_check_bounds::<Self>(offset);
6266 fidl::decode!(
6268 PlayerApplicationSettings,
6269 D,
6270 &mut self.requested_settings,
6271 decoder,
6272 offset + 0,
6273 _depth
6274 )?;
6275 Ok(())
6276 }
6277 }
6278
6279 impl fidl::encoding::ValueTypeMarker for TargetHandlerWatchNotificationRequest {
6280 type Borrowed<'a> = &'a Self;
6281 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6282 value
6283 }
6284 }
6285
6286 unsafe impl fidl::encoding::TypeMarker for TargetHandlerWatchNotificationRequest {
6287 type Owned = Self;
6288
6289 #[inline(always)]
6290 fn inline_align(_context: fidl::encoding::Context) -> usize {
6291 8
6292 }
6293
6294 #[inline(always)]
6295 fn inline_size(_context: fidl::encoding::Context) -> usize {
6296 32
6297 }
6298 }
6299
6300 unsafe impl<D: fidl::encoding::ResourceDialect>
6301 fidl::encoding::Encode<TargetHandlerWatchNotificationRequest, D>
6302 for &TargetHandlerWatchNotificationRequest
6303 {
6304 #[inline]
6305 unsafe fn encode(
6306 self,
6307 encoder: &mut fidl::encoding::Encoder<'_, D>,
6308 offset: usize,
6309 _depth: fidl::encoding::Depth,
6310 ) -> fidl::Result<()> {
6311 encoder.debug_check_bounds::<TargetHandlerWatchNotificationRequest>(offset);
6312 fidl::encoding::Encode::<TargetHandlerWatchNotificationRequest, D>::encode(
6314 (
6315 <NotificationEvent as fidl::encoding::ValueTypeMarker>::borrow(&self.event_id),
6316 <Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.current),
6317 <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.pos_change_interval),
6318 ),
6319 encoder,
6320 offset,
6321 _depth,
6322 )
6323 }
6324 }
6325 unsafe impl<
6326 D: fidl::encoding::ResourceDialect,
6327 T0: fidl::encoding::Encode<NotificationEvent, D>,
6328 T1: fidl::encoding::Encode<Notification, D>,
6329 T2: fidl::encoding::Encode<u32, D>,
6330 > fidl::encoding::Encode<TargetHandlerWatchNotificationRequest, D> for (T0, T1, T2)
6331 {
6332 #[inline]
6333 unsafe fn encode(
6334 self,
6335 encoder: &mut fidl::encoding::Encoder<'_, D>,
6336 offset: usize,
6337 depth: fidl::encoding::Depth,
6338 ) -> fidl::Result<()> {
6339 encoder.debug_check_bounds::<TargetHandlerWatchNotificationRequest>(offset);
6340 unsafe {
6343 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
6344 (ptr as *mut u64).write_unaligned(0);
6345 }
6346 unsafe {
6347 let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
6348 (ptr as *mut u64).write_unaligned(0);
6349 }
6350 self.0.encode(encoder, offset + 0, depth)?;
6352 self.1.encode(encoder, offset + 8, depth)?;
6353 self.2.encode(encoder, offset + 24, depth)?;
6354 Ok(())
6355 }
6356 }
6357
6358 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6359 for TargetHandlerWatchNotificationRequest
6360 {
6361 #[inline(always)]
6362 fn new_empty() -> Self {
6363 Self {
6364 event_id: fidl::new_empty!(NotificationEvent, D),
6365 current: fidl::new_empty!(Notification, D),
6366 pos_change_interval: fidl::new_empty!(u32, D),
6367 }
6368 }
6369
6370 #[inline]
6371 unsafe fn decode(
6372 &mut self,
6373 decoder: &mut fidl::encoding::Decoder<'_, D>,
6374 offset: usize,
6375 _depth: fidl::encoding::Depth,
6376 ) -> fidl::Result<()> {
6377 decoder.debug_check_bounds::<Self>(offset);
6378 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
6380 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6381 let mask = 0xffffffffffffff00u64;
6382 let maskedval = padval & mask;
6383 if maskedval != 0 {
6384 return Err(fidl::Error::NonZeroPadding {
6385 padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
6386 });
6387 }
6388 let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
6389 let padval = unsafe { (ptr as *const u64).read_unaligned() };
6390 let mask = 0xffffffff00000000u64;
6391 let maskedval = padval & mask;
6392 if maskedval != 0 {
6393 return Err(fidl::Error::NonZeroPadding {
6394 padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
6395 });
6396 }
6397 fidl::decode!(NotificationEvent, D, &mut self.event_id, decoder, offset + 0, _depth)?;
6398 fidl::decode!(Notification, D, &mut self.current, decoder, offset + 8, _depth)?;
6399 fidl::decode!(u32, D, &mut self.pos_change_interval, decoder, offset + 24, _depth)?;
6400 Ok(())
6401 }
6402 }
6403
6404 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetEventsSupportedResponse {
6405 type Borrowed<'a> = &'a Self;
6406 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6407 value
6408 }
6409 }
6410
6411 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetEventsSupportedResponse {
6412 type Owned = Self;
6413
6414 #[inline(always)]
6415 fn inline_align(_context: fidl::encoding::Context) -> usize {
6416 8
6417 }
6418
6419 #[inline(always)]
6420 fn inline_size(_context: fidl::encoding::Context) -> usize {
6421 16
6422 }
6423 }
6424
6425 unsafe impl<D: fidl::encoding::ResourceDialect>
6426 fidl::encoding::Encode<TargetHandlerGetEventsSupportedResponse, D>
6427 for &TargetHandlerGetEventsSupportedResponse
6428 {
6429 #[inline]
6430 unsafe fn encode(
6431 self,
6432 encoder: &mut fidl::encoding::Encoder<'_, D>,
6433 offset: usize,
6434 _depth: fidl::encoding::Depth,
6435 ) -> fidl::Result<()> {
6436 encoder.debug_check_bounds::<TargetHandlerGetEventsSupportedResponse>(offset);
6437 fidl::encoding::Encode::<TargetHandlerGetEventsSupportedResponse, D>::encode(
6439 (
6440 <fidl::encoding::Vector<NotificationEvent, 255> as fidl::encoding::ValueTypeMarker>::borrow(&self.notification_ids),
6441 ),
6442 encoder, offset, _depth
6443 )
6444 }
6445 }
6446 unsafe impl<
6447 D: fidl::encoding::ResourceDialect,
6448 T0: fidl::encoding::Encode<fidl::encoding::Vector<NotificationEvent, 255>, D>,
6449 > fidl::encoding::Encode<TargetHandlerGetEventsSupportedResponse, D> for (T0,)
6450 {
6451 #[inline]
6452 unsafe fn encode(
6453 self,
6454 encoder: &mut fidl::encoding::Encoder<'_, D>,
6455 offset: usize,
6456 depth: fidl::encoding::Depth,
6457 ) -> fidl::Result<()> {
6458 encoder.debug_check_bounds::<TargetHandlerGetEventsSupportedResponse>(offset);
6459 self.0.encode(encoder, offset + 0, depth)?;
6463 Ok(())
6464 }
6465 }
6466
6467 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6468 for TargetHandlerGetEventsSupportedResponse
6469 {
6470 #[inline(always)]
6471 fn new_empty() -> Self {
6472 Self {
6473 notification_ids: fidl::new_empty!(fidl::encoding::Vector<NotificationEvent, 255>, D),
6474 }
6475 }
6476
6477 #[inline]
6478 unsafe fn decode(
6479 &mut self,
6480 decoder: &mut fidl::encoding::Decoder<'_, D>,
6481 offset: usize,
6482 _depth: fidl::encoding::Depth,
6483 ) -> fidl::Result<()> {
6484 decoder.debug_check_bounds::<Self>(offset);
6485 fidl::decode!(fidl::encoding::Vector<NotificationEvent, 255>, D, &mut self.notification_ids, decoder, offset + 0, _depth)?;
6487 Ok(())
6488 }
6489 }
6490
6491 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetMediaAttributesResponse {
6492 type Borrowed<'a> = &'a Self;
6493 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6494 value
6495 }
6496 }
6497
6498 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetMediaAttributesResponse {
6499 type Owned = Self;
6500
6501 #[inline(always)]
6502 fn inline_align(_context: fidl::encoding::Context) -> usize {
6503 8
6504 }
6505
6506 #[inline(always)]
6507 fn inline_size(_context: fidl::encoding::Context) -> usize {
6508 16
6509 }
6510 }
6511
6512 unsafe impl<D: fidl::encoding::ResourceDialect>
6513 fidl::encoding::Encode<TargetHandlerGetMediaAttributesResponse, D>
6514 for &TargetHandlerGetMediaAttributesResponse
6515 {
6516 #[inline]
6517 unsafe fn encode(
6518 self,
6519 encoder: &mut fidl::encoding::Encoder<'_, D>,
6520 offset: usize,
6521 _depth: fidl::encoding::Depth,
6522 ) -> fidl::Result<()> {
6523 encoder.debug_check_bounds::<TargetHandlerGetMediaAttributesResponse>(offset);
6524 fidl::encoding::Encode::<TargetHandlerGetMediaAttributesResponse, D>::encode(
6526 (<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),),
6527 encoder,
6528 offset,
6529 _depth,
6530 )
6531 }
6532 }
6533 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<MediaAttributes, D>>
6534 fidl::encoding::Encode<TargetHandlerGetMediaAttributesResponse, D> for (T0,)
6535 {
6536 #[inline]
6537 unsafe fn encode(
6538 self,
6539 encoder: &mut fidl::encoding::Encoder<'_, D>,
6540 offset: usize,
6541 depth: fidl::encoding::Depth,
6542 ) -> fidl::Result<()> {
6543 encoder.debug_check_bounds::<TargetHandlerGetMediaAttributesResponse>(offset);
6544 self.0.encode(encoder, offset + 0, depth)?;
6548 Ok(())
6549 }
6550 }
6551
6552 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6553 for TargetHandlerGetMediaAttributesResponse
6554 {
6555 #[inline(always)]
6556 fn new_empty() -> Self {
6557 Self { attributes: fidl::new_empty!(MediaAttributes, D) }
6558 }
6559
6560 #[inline]
6561 unsafe fn decode(
6562 &mut self,
6563 decoder: &mut fidl::encoding::Decoder<'_, D>,
6564 offset: usize,
6565 _depth: fidl::encoding::Depth,
6566 ) -> fidl::Result<()> {
6567 decoder.debug_check_bounds::<Self>(offset);
6568 fidl::decode!(MediaAttributes, D, &mut self.attributes, decoder, offset + 0, _depth)?;
6570 Ok(())
6571 }
6572 }
6573
6574 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetMediaPlayerItemsResponse {
6575 type Borrowed<'a> = &'a Self;
6576 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6577 value
6578 }
6579 }
6580
6581 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetMediaPlayerItemsResponse {
6582 type Owned = Self;
6583
6584 #[inline(always)]
6585 fn inline_align(_context: fidl::encoding::Context) -> usize {
6586 8
6587 }
6588
6589 #[inline(always)]
6590 fn inline_size(_context: fidl::encoding::Context) -> usize {
6591 16
6592 }
6593 }
6594
6595 unsafe impl<D: fidl::encoding::ResourceDialect>
6596 fidl::encoding::Encode<TargetHandlerGetMediaPlayerItemsResponse, D>
6597 for &TargetHandlerGetMediaPlayerItemsResponse
6598 {
6599 #[inline]
6600 unsafe fn encode(
6601 self,
6602 encoder: &mut fidl::encoding::Encoder<'_, D>,
6603 offset: usize,
6604 _depth: fidl::encoding::Depth,
6605 ) -> fidl::Result<()> {
6606 encoder.debug_check_bounds::<TargetHandlerGetMediaPlayerItemsResponse>(offset);
6607 fidl::encoding::Encode::<TargetHandlerGetMediaPlayerItemsResponse, D>::encode(
6609 (
6610 <fidl::encoding::Vector<MediaPlayerItem, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.items),
6611 ),
6612 encoder, offset, _depth
6613 )
6614 }
6615 }
6616 unsafe impl<
6617 D: fidl::encoding::ResourceDialect,
6618 T0: fidl::encoding::Encode<fidl::encoding::Vector<MediaPlayerItem, 16>, D>,
6619 > fidl::encoding::Encode<TargetHandlerGetMediaPlayerItemsResponse, D> for (T0,)
6620 {
6621 #[inline]
6622 unsafe fn encode(
6623 self,
6624 encoder: &mut fidl::encoding::Encoder<'_, D>,
6625 offset: usize,
6626 depth: fidl::encoding::Depth,
6627 ) -> fidl::Result<()> {
6628 encoder.debug_check_bounds::<TargetHandlerGetMediaPlayerItemsResponse>(offset);
6629 self.0.encode(encoder, offset + 0, depth)?;
6633 Ok(())
6634 }
6635 }
6636
6637 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6638 for TargetHandlerGetMediaPlayerItemsResponse
6639 {
6640 #[inline(always)]
6641 fn new_empty() -> Self {
6642 Self { items: fidl::new_empty!(fidl::encoding::Vector<MediaPlayerItem, 16>, D) }
6643 }
6644
6645 #[inline]
6646 unsafe fn decode(
6647 &mut self,
6648 decoder: &mut fidl::encoding::Decoder<'_, D>,
6649 offset: usize,
6650 _depth: fidl::encoding::Depth,
6651 ) -> fidl::Result<()> {
6652 decoder.debug_check_bounds::<Self>(offset);
6653 fidl::decode!(fidl::encoding::Vector<MediaPlayerItem, 16>, D, &mut self.items, decoder, offset + 0, _depth)?;
6655 Ok(())
6656 }
6657 }
6658
6659 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetNotificationResponse {
6660 type Borrowed<'a> = &'a Self;
6661 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6662 value
6663 }
6664 }
6665
6666 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetNotificationResponse {
6667 type Owned = Self;
6668
6669 #[inline(always)]
6670 fn inline_align(_context: fidl::encoding::Context) -> usize {
6671 8
6672 }
6673
6674 #[inline(always)]
6675 fn inline_size(_context: fidl::encoding::Context) -> usize {
6676 16
6677 }
6678 }
6679
6680 unsafe impl<D: fidl::encoding::ResourceDialect>
6681 fidl::encoding::Encode<TargetHandlerGetNotificationResponse, D>
6682 for &TargetHandlerGetNotificationResponse
6683 {
6684 #[inline]
6685 unsafe fn encode(
6686 self,
6687 encoder: &mut fidl::encoding::Encoder<'_, D>,
6688 offset: usize,
6689 _depth: fidl::encoding::Depth,
6690 ) -> fidl::Result<()> {
6691 encoder.debug_check_bounds::<TargetHandlerGetNotificationResponse>(offset);
6692 fidl::encoding::Encode::<TargetHandlerGetNotificationResponse, D>::encode(
6694 (<Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.current_value),),
6695 encoder,
6696 offset,
6697 _depth,
6698 )
6699 }
6700 }
6701 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Notification, D>>
6702 fidl::encoding::Encode<TargetHandlerGetNotificationResponse, D> for (T0,)
6703 {
6704 #[inline]
6705 unsafe fn encode(
6706 self,
6707 encoder: &mut fidl::encoding::Encoder<'_, D>,
6708 offset: usize,
6709 depth: fidl::encoding::Depth,
6710 ) -> fidl::Result<()> {
6711 encoder.debug_check_bounds::<TargetHandlerGetNotificationResponse>(offset);
6712 self.0.encode(encoder, offset + 0, depth)?;
6716 Ok(())
6717 }
6718 }
6719
6720 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6721 for TargetHandlerGetNotificationResponse
6722 {
6723 #[inline(always)]
6724 fn new_empty() -> Self {
6725 Self { current_value: fidl::new_empty!(Notification, D) }
6726 }
6727
6728 #[inline]
6729 unsafe fn decode(
6730 &mut self,
6731 decoder: &mut fidl::encoding::Decoder<'_, D>,
6732 offset: usize,
6733 _depth: fidl::encoding::Depth,
6734 ) -> fidl::Result<()> {
6735 decoder.debug_check_bounds::<Self>(offset);
6736 fidl::decode!(Notification, D, &mut self.current_value, decoder, offset + 0, _depth)?;
6738 Ok(())
6739 }
6740 }
6741
6742 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayStatusResponse {
6743 type Borrowed<'a> = &'a Self;
6744 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6745 value
6746 }
6747 }
6748
6749 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayStatusResponse {
6750 type Owned = Self;
6751
6752 #[inline(always)]
6753 fn inline_align(_context: fidl::encoding::Context) -> usize {
6754 8
6755 }
6756
6757 #[inline(always)]
6758 fn inline_size(_context: fidl::encoding::Context) -> usize {
6759 16
6760 }
6761 }
6762
6763 unsafe impl<D: fidl::encoding::ResourceDialect>
6764 fidl::encoding::Encode<TargetHandlerGetPlayStatusResponse, D>
6765 for &TargetHandlerGetPlayStatusResponse
6766 {
6767 #[inline]
6768 unsafe fn encode(
6769 self,
6770 encoder: &mut fidl::encoding::Encoder<'_, D>,
6771 offset: usize,
6772 _depth: fidl::encoding::Depth,
6773 ) -> fidl::Result<()> {
6774 encoder.debug_check_bounds::<TargetHandlerGetPlayStatusResponse>(offset);
6775 fidl::encoding::Encode::<TargetHandlerGetPlayStatusResponse, D>::encode(
6777 (<PlayStatus as fidl::encoding::ValueTypeMarker>::borrow(&self.play_status),),
6778 encoder,
6779 offset,
6780 _depth,
6781 )
6782 }
6783 }
6784 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PlayStatus, D>>
6785 fidl::encoding::Encode<TargetHandlerGetPlayStatusResponse, D> for (T0,)
6786 {
6787 #[inline]
6788 unsafe fn encode(
6789 self,
6790 encoder: &mut fidl::encoding::Encoder<'_, D>,
6791 offset: usize,
6792 depth: fidl::encoding::Depth,
6793 ) -> fidl::Result<()> {
6794 encoder.debug_check_bounds::<TargetHandlerGetPlayStatusResponse>(offset);
6795 self.0.encode(encoder, offset + 0, depth)?;
6799 Ok(())
6800 }
6801 }
6802
6803 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6804 for TargetHandlerGetPlayStatusResponse
6805 {
6806 #[inline(always)]
6807 fn new_empty() -> Self {
6808 Self { play_status: fidl::new_empty!(PlayStatus, D) }
6809 }
6810
6811 #[inline]
6812 unsafe fn decode(
6813 &mut self,
6814 decoder: &mut fidl::encoding::Decoder<'_, D>,
6815 offset: usize,
6816 _depth: fidl::encoding::Depth,
6817 ) -> fidl::Result<()> {
6818 decoder.debug_check_bounds::<Self>(offset);
6819 fidl::decode!(PlayStatus, D, &mut self.play_status, decoder, offset + 0, _depth)?;
6821 Ok(())
6822 }
6823 }
6824
6825 impl fidl::encoding::ValueTypeMarker for TargetHandlerGetPlayerApplicationSettingsResponse {
6826 type Borrowed<'a> = &'a Self;
6827 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6828 value
6829 }
6830 }
6831
6832 unsafe impl fidl::encoding::TypeMarker for TargetHandlerGetPlayerApplicationSettingsResponse {
6833 type Owned = Self;
6834
6835 #[inline(always)]
6836 fn inline_align(_context: fidl::encoding::Context) -> usize {
6837 8
6838 }
6839
6840 #[inline(always)]
6841 fn inline_size(_context: fidl::encoding::Context) -> usize {
6842 16
6843 }
6844 }
6845
6846 unsafe impl<D: fidl::encoding::ResourceDialect>
6847 fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsResponse, D>
6848 for &TargetHandlerGetPlayerApplicationSettingsResponse
6849 {
6850 #[inline]
6851 unsafe fn encode(
6852 self,
6853 encoder: &mut fidl::encoding::Encoder<'_, D>,
6854 offset: usize,
6855 _depth: fidl::encoding::Depth,
6856 ) -> fidl::Result<()> {
6857 encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsResponse>(offset);
6858 fidl::encoding::Encode::<TargetHandlerGetPlayerApplicationSettingsResponse, D>::encode(
6860 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
6861 &self.current_settings,
6862 ),),
6863 encoder,
6864 offset,
6865 _depth,
6866 )
6867 }
6868 }
6869 unsafe impl<
6870 D: fidl::encoding::ResourceDialect,
6871 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
6872 > fidl::encoding::Encode<TargetHandlerGetPlayerApplicationSettingsResponse, D> for (T0,)
6873 {
6874 #[inline]
6875 unsafe fn encode(
6876 self,
6877 encoder: &mut fidl::encoding::Encoder<'_, D>,
6878 offset: usize,
6879 depth: fidl::encoding::Depth,
6880 ) -> fidl::Result<()> {
6881 encoder.debug_check_bounds::<TargetHandlerGetPlayerApplicationSettingsResponse>(offset);
6882 self.0.encode(encoder, offset + 0, depth)?;
6886 Ok(())
6887 }
6888 }
6889
6890 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6891 for TargetHandlerGetPlayerApplicationSettingsResponse
6892 {
6893 #[inline(always)]
6894 fn new_empty() -> Self {
6895 Self { current_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
6896 }
6897
6898 #[inline]
6899 unsafe fn decode(
6900 &mut self,
6901 decoder: &mut fidl::encoding::Decoder<'_, D>,
6902 offset: usize,
6903 _depth: fidl::encoding::Depth,
6904 ) -> fidl::Result<()> {
6905 decoder.debug_check_bounds::<Self>(offset);
6906 fidl::decode!(
6908 PlayerApplicationSettings,
6909 D,
6910 &mut self.current_settings,
6911 decoder,
6912 offset + 0,
6913 _depth
6914 )?;
6915 Ok(())
6916 }
6917 }
6918
6919 impl fidl::encoding::ValueTypeMarker
6920 for TargetHandlerListPlayerApplicationSettingAttributesResponse
6921 {
6922 type Borrowed<'a> = &'a Self;
6923 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6924 value
6925 }
6926 }
6927
6928 unsafe impl fidl::encoding::TypeMarker
6929 for TargetHandlerListPlayerApplicationSettingAttributesResponse
6930 {
6931 type Owned = Self;
6932
6933 #[inline(always)]
6934 fn inline_align(_context: fidl::encoding::Context) -> usize {
6935 8
6936 }
6937
6938 #[inline(always)]
6939 fn inline_size(_context: fidl::encoding::Context) -> usize {
6940 16
6941 }
6942 }
6943
6944 unsafe impl<D: fidl::encoding::ResourceDialect>
6945 fidl::encoding::Encode<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>
6946 for &TargetHandlerListPlayerApplicationSettingAttributesResponse
6947 {
6948 #[inline]
6949 unsafe fn encode(
6950 self,
6951 encoder: &mut fidl::encoding::Encoder<'_, D>,
6952 offset: usize,
6953 _depth: fidl::encoding::Depth,
6954 ) -> fidl::Result<()> {
6955 encoder
6956 .debug_check_bounds::<TargetHandlerListPlayerApplicationSettingAttributesResponse>(
6957 offset,
6958 );
6959 fidl::encoding::Encode::<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>::encode(
6961 (
6962 <fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131> as fidl::encoding::ValueTypeMarker>::borrow(&self.attributes),
6963 ),
6964 encoder, offset, _depth
6965 )
6966 }
6967 }
6968 unsafe impl<
6969 D: fidl::encoding::ResourceDialect,
6970 T0: fidl::encoding::Encode<
6971 fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>,
6972 D,
6973 >,
6974 > fidl::encoding::Encode<TargetHandlerListPlayerApplicationSettingAttributesResponse, D>
6975 for (T0,)
6976 {
6977 #[inline]
6978 unsafe fn encode(
6979 self,
6980 encoder: &mut fidl::encoding::Encoder<'_, D>,
6981 offset: usize,
6982 depth: fidl::encoding::Depth,
6983 ) -> fidl::Result<()> {
6984 encoder
6985 .debug_check_bounds::<TargetHandlerListPlayerApplicationSettingAttributesResponse>(
6986 offset,
6987 );
6988 self.0.encode(encoder, offset + 0, depth)?;
6992 Ok(())
6993 }
6994 }
6995
6996 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6997 for TargetHandlerListPlayerApplicationSettingAttributesResponse
6998 {
6999 #[inline(always)]
7000 fn new_empty() -> Self {
7001 Self {
7002 attributes: fidl::new_empty!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D),
7003 }
7004 }
7005
7006 #[inline]
7007 unsafe fn decode(
7008 &mut self,
7009 decoder: &mut fidl::encoding::Decoder<'_, D>,
7010 offset: usize,
7011 _depth: fidl::encoding::Depth,
7012 ) -> fidl::Result<()> {
7013 decoder.debug_check_bounds::<Self>(offset);
7014 fidl::decode!(fidl::encoding::Vector<PlayerApplicationSettingAttributeId, 131>, D, &mut self.attributes, decoder, offset + 0, _depth)?;
7016 Ok(())
7017 }
7018 }
7019
7020 impl fidl::encoding::ValueTypeMarker for TargetHandlerSetPlayerApplicationSettingsResponse {
7021 type Borrowed<'a> = &'a Self;
7022 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7023 value
7024 }
7025 }
7026
7027 unsafe impl fidl::encoding::TypeMarker for TargetHandlerSetPlayerApplicationSettingsResponse {
7028 type Owned = Self;
7029
7030 #[inline(always)]
7031 fn inline_align(_context: fidl::encoding::Context) -> usize {
7032 8
7033 }
7034
7035 #[inline(always)]
7036 fn inline_size(_context: fidl::encoding::Context) -> usize {
7037 16
7038 }
7039 }
7040
7041 unsafe impl<D: fidl::encoding::ResourceDialect>
7042 fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsResponse, D>
7043 for &TargetHandlerSetPlayerApplicationSettingsResponse
7044 {
7045 #[inline]
7046 unsafe fn encode(
7047 self,
7048 encoder: &mut fidl::encoding::Encoder<'_, D>,
7049 offset: usize,
7050 _depth: fidl::encoding::Depth,
7051 ) -> fidl::Result<()> {
7052 encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsResponse>(offset);
7053 fidl::encoding::Encode::<TargetHandlerSetPlayerApplicationSettingsResponse, D>::encode(
7055 (<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow(
7056 &self.set_settings,
7057 ),),
7058 encoder,
7059 offset,
7060 _depth,
7061 )
7062 }
7063 }
7064 unsafe impl<
7065 D: fidl::encoding::ResourceDialect,
7066 T0: fidl::encoding::Encode<PlayerApplicationSettings, D>,
7067 > fidl::encoding::Encode<TargetHandlerSetPlayerApplicationSettingsResponse, D> for (T0,)
7068 {
7069 #[inline]
7070 unsafe fn encode(
7071 self,
7072 encoder: &mut fidl::encoding::Encoder<'_, D>,
7073 offset: usize,
7074 depth: fidl::encoding::Depth,
7075 ) -> fidl::Result<()> {
7076 encoder.debug_check_bounds::<TargetHandlerSetPlayerApplicationSettingsResponse>(offset);
7077 self.0.encode(encoder, offset + 0, depth)?;
7081 Ok(())
7082 }
7083 }
7084
7085 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7086 for TargetHandlerSetPlayerApplicationSettingsResponse
7087 {
7088 #[inline(always)]
7089 fn new_empty() -> Self {
7090 Self { set_settings: fidl::new_empty!(PlayerApplicationSettings, D) }
7091 }
7092
7093 #[inline]
7094 unsafe fn decode(
7095 &mut self,
7096 decoder: &mut fidl::encoding::Decoder<'_, D>,
7097 offset: usize,
7098 _depth: fidl::encoding::Depth,
7099 ) -> fidl::Result<()> {
7100 decoder.debug_check_bounds::<Self>(offset);
7101 fidl::decode!(
7103 PlayerApplicationSettings,
7104 D,
7105 &mut self.set_settings,
7106 decoder,
7107 offset + 0,
7108 _depth
7109 )?;
7110 Ok(())
7111 }
7112 }
7113
7114 impl fidl::encoding::ValueTypeMarker for TargetHandlerWatchNotificationResponse {
7115 type Borrowed<'a> = &'a Self;
7116 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7117 value
7118 }
7119 }
7120
7121 unsafe impl fidl::encoding::TypeMarker for TargetHandlerWatchNotificationResponse {
7122 type Owned = Self;
7123
7124 #[inline(always)]
7125 fn inline_align(_context: fidl::encoding::Context) -> usize {
7126 8
7127 }
7128
7129 #[inline(always)]
7130 fn inline_size(_context: fidl::encoding::Context) -> usize {
7131 16
7132 }
7133 }
7134
7135 unsafe impl<D: fidl::encoding::ResourceDialect>
7136 fidl::encoding::Encode<TargetHandlerWatchNotificationResponse, D>
7137 for &TargetHandlerWatchNotificationResponse
7138 {
7139 #[inline]
7140 unsafe fn encode(
7141 self,
7142 encoder: &mut fidl::encoding::Encoder<'_, D>,
7143 offset: usize,
7144 _depth: fidl::encoding::Depth,
7145 ) -> fidl::Result<()> {
7146 encoder.debug_check_bounds::<TargetHandlerWatchNotificationResponse>(offset);
7147 fidl::encoding::Encode::<TargetHandlerWatchNotificationResponse, D>::encode(
7149 (<Notification as fidl::encoding::ValueTypeMarker>::borrow(&self.new_value),),
7150 encoder,
7151 offset,
7152 _depth,
7153 )
7154 }
7155 }
7156 unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Notification, D>>
7157 fidl::encoding::Encode<TargetHandlerWatchNotificationResponse, D> for (T0,)
7158 {
7159 #[inline]
7160 unsafe fn encode(
7161 self,
7162 encoder: &mut fidl::encoding::Encoder<'_, D>,
7163 offset: usize,
7164 depth: fidl::encoding::Depth,
7165 ) -> fidl::Result<()> {
7166 encoder.debug_check_bounds::<TargetHandlerWatchNotificationResponse>(offset);
7167 self.0.encode(encoder, offset + 0, depth)?;
7171 Ok(())
7172 }
7173 }
7174
7175 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7176 for TargetHandlerWatchNotificationResponse
7177 {
7178 #[inline(always)]
7179 fn new_empty() -> Self {
7180 Self { new_value: fidl::new_empty!(Notification, D) }
7181 }
7182
7183 #[inline]
7184 unsafe fn decode(
7185 &mut self,
7186 decoder: &mut fidl::encoding::Decoder<'_, D>,
7187 offset: usize,
7188 _depth: fidl::encoding::Depth,
7189 ) -> fidl::Result<()> {
7190 decoder.debug_check_bounds::<Self>(offset);
7191 fidl::decode!(Notification, D, &mut self.new_value, decoder, offset + 0, _depth)?;
7193 Ok(())
7194 }
7195 }
7196
7197 impl CustomPlayerApplicationSetting {
7198 #[inline(always)]
7199 fn max_ordinal_present(&self) -> u64 {
7200 if let Some(_) = self.current_value {
7201 return 4;
7202 }
7203 if let Some(_) = self.possible_values {
7204 return 3;
7205 }
7206 if let Some(_) = self.attribute_name {
7207 return 2;
7208 }
7209 if let Some(_) = self.attribute_id {
7210 return 1;
7211 }
7212 0
7213 }
7214 }
7215
7216 impl fidl::encoding::ValueTypeMarker for CustomPlayerApplicationSetting {
7217 type Borrowed<'a> = &'a Self;
7218 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7219 value
7220 }
7221 }
7222
7223 unsafe impl fidl::encoding::TypeMarker for CustomPlayerApplicationSetting {
7224 type Owned = Self;
7225
7226 #[inline(always)]
7227 fn inline_align(_context: fidl::encoding::Context) -> usize {
7228 8
7229 }
7230
7231 #[inline(always)]
7232 fn inline_size(_context: fidl::encoding::Context) -> usize {
7233 16
7234 }
7235 }
7236
7237 unsafe impl<D: fidl::encoding::ResourceDialect>
7238 fidl::encoding::Encode<CustomPlayerApplicationSetting, D>
7239 for &CustomPlayerApplicationSetting
7240 {
7241 unsafe fn encode(
7242 self,
7243 encoder: &mut fidl::encoding::Encoder<'_, D>,
7244 offset: usize,
7245 mut depth: fidl::encoding::Depth,
7246 ) -> fidl::Result<()> {
7247 encoder.debug_check_bounds::<CustomPlayerApplicationSetting>(offset);
7248 let max_ordinal: u64 = self.max_ordinal_present();
7250 encoder.write_num(max_ordinal, offset);
7251 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7252 if max_ordinal == 0 {
7254 return Ok(());
7255 }
7256 depth.increment()?;
7257 let envelope_size = 8;
7258 let bytes_len = max_ordinal as usize * envelope_size;
7259 #[allow(unused_variables)]
7260 let offset = encoder.out_of_line_offset(bytes_len);
7261 let mut _prev_end_offset: usize = 0;
7262 if 1 > max_ordinal {
7263 return Ok(());
7264 }
7265
7266 let cur_offset: usize = (1 - 1) * envelope_size;
7269
7270 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7272
7273 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7278 self.attribute_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7279 encoder,
7280 offset + cur_offset,
7281 depth,
7282 )?;
7283
7284 _prev_end_offset = cur_offset + envelope_size;
7285 if 2 > max_ordinal {
7286 return Ok(());
7287 }
7288
7289 let cur_offset: usize = (2 - 1) * envelope_size;
7292
7293 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7295
7296 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7301 self.attribute_name.as_ref().map(
7302 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7303 ),
7304 encoder,
7305 offset + cur_offset,
7306 depth,
7307 )?;
7308
7309 _prev_end_offset = cur_offset + envelope_size;
7310 if 3 > max_ordinal {
7311 return Ok(());
7312 }
7313
7314 let cur_offset: usize = (3 - 1) * envelope_size;
7317
7318 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7320
7321 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CustomAttributeValue, 255>, D>(
7326 self.possible_values.as_ref().map(<fidl::encoding::Vector<CustomAttributeValue, 255> as fidl::encoding::ValueTypeMarker>::borrow),
7327 encoder, offset + cur_offset, depth
7328 )?;
7329
7330 _prev_end_offset = cur_offset + envelope_size;
7331 if 4 > max_ordinal {
7332 return Ok(());
7333 }
7334
7335 let cur_offset: usize = (4 - 1) * envelope_size;
7338
7339 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7341
7342 fidl::encoding::encode_in_envelope_optional::<u8, D>(
7347 self.current_value.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7348 encoder,
7349 offset + cur_offset,
7350 depth,
7351 )?;
7352
7353 _prev_end_offset = cur_offset + envelope_size;
7354
7355 Ok(())
7356 }
7357 }
7358
7359 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7360 for CustomPlayerApplicationSetting
7361 {
7362 #[inline(always)]
7363 fn new_empty() -> Self {
7364 Self::default()
7365 }
7366
7367 unsafe fn decode(
7368 &mut self,
7369 decoder: &mut fidl::encoding::Decoder<'_, D>,
7370 offset: usize,
7371 mut depth: fidl::encoding::Depth,
7372 ) -> fidl::Result<()> {
7373 decoder.debug_check_bounds::<Self>(offset);
7374 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7375 None => return Err(fidl::Error::NotNullable),
7376 Some(len) => len,
7377 };
7378 if len == 0 {
7380 return Ok(());
7381 };
7382 depth.increment()?;
7383 let envelope_size = 8;
7384 let bytes_len = len * envelope_size;
7385 let offset = decoder.out_of_line_offset(bytes_len)?;
7386 let mut _next_ordinal_to_read = 0;
7388 let mut next_offset = offset;
7389 let end_offset = offset + bytes_len;
7390 _next_ordinal_to_read += 1;
7391 if next_offset >= end_offset {
7392 return Ok(());
7393 }
7394
7395 while _next_ordinal_to_read < 1 {
7397 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7398 _next_ordinal_to_read += 1;
7399 next_offset += envelope_size;
7400 }
7401
7402 let next_out_of_line = decoder.next_out_of_line();
7403 let handles_before = decoder.remaining_handles();
7404 if let Some((inlined, num_bytes, num_handles)) =
7405 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7406 {
7407 let member_inline_size =
7408 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7409 if inlined != (member_inline_size <= 4) {
7410 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7411 }
7412 let inner_offset;
7413 let mut inner_depth = depth.clone();
7414 if inlined {
7415 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7416 inner_offset = next_offset;
7417 } else {
7418 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7419 inner_depth.increment()?;
7420 }
7421 let val_ref = self.attribute_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7422 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7423 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7424 {
7425 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7426 }
7427 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7428 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7429 }
7430 }
7431
7432 next_offset += envelope_size;
7433 _next_ordinal_to_read += 1;
7434 if next_offset >= end_offset {
7435 return Ok(());
7436 }
7437
7438 while _next_ordinal_to_read < 2 {
7440 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7441 _next_ordinal_to_read += 1;
7442 next_offset += envelope_size;
7443 }
7444
7445 let next_out_of_line = decoder.next_out_of_line();
7446 let handles_before = decoder.remaining_handles();
7447 if let Some((inlined, num_bytes, num_handles)) =
7448 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7449 {
7450 let member_inline_size =
7451 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7452 decoder.context,
7453 );
7454 if inlined != (member_inline_size <= 4) {
7455 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7456 }
7457 let inner_offset;
7458 let mut inner_depth = depth.clone();
7459 if inlined {
7460 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7461 inner_offset = next_offset;
7462 } else {
7463 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7464 inner_depth.increment()?;
7465 }
7466 let val_ref = self
7467 .attribute_name
7468 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7469 fidl::decode!(
7470 fidl::encoding::BoundedString<255>,
7471 D,
7472 val_ref,
7473 decoder,
7474 inner_offset,
7475 inner_depth
7476 )?;
7477 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7478 {
7479 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7480 }
7481 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7482 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7483 }
7484 }
7485
7486 next_offset += envelope_size;
7487 _next_ordinal_to_read += 1;
7488 if next_offset >= end_offset {
7489 return Ok(());
7490 }
7491
7492 while _next_ordinal_to_read < 3 {
7494 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7495 _next_ordinal_to_read += 1;
7496 next_offset += envelope_size;
7497 }
7498
7499 let next_out_of_line = decoder.next_out_of_line();
7500 let handles_before = decoder.remaining_handles();
7501 if let Some((inlined, num_bytes, num_handles)) =
7502 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7503 {
7504 let member_inline_size = <fidl::encoding::Vector<CustomAttributeValue, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7505 if inlined != (member_inline_size <= 4) {
7506 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7507 }
7508 let inner_offset;
7509 let mut inner_depth = depth.clone();
7510 if inlined {
7511 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7512 inner_offset = next_offset;
7513 } else {
7514 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7515 inner_depth.increment()?;
7516 }
7517 let val_ref = self.possible_values.get_or_insert_with(
7518 || fidl::new_empty!(fidl::encoding::Vector<CustomAttributeValue, 255>, D),
7519 );
7520 fidl::decode!(fidl::encoding::Vector<CustomAttributeValue, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
7521 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7522 {
7523 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7524 }
7525 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7526 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7527 }
7528 }
7529
7530 next_offset += envelope_size;
7531 _next_ordinal_to_read += 1;
7532 if next_offset >= end_offset {
7533 return Ok(());
7534 }
7535
7536 while _next_ordinal_to_read < 4 {
7538 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7539 _next_ordinal_to_read += 1;
7540 next_offset += envelope_size;
7541 }
7542
7543 let next_out_of_line = decoder.next_out_of_line();
7544 let handles_before = decoder.remaining_handles();
7545 if let Some((inlined, num_bytes, num_handles)) =
7546 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7547 {
7548 let member_inline_size =
7549 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7550 if inlined != (member_inline_size <= 4) {
7551 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7552 }
7553 let inner_offset;
7554 let mut inner_depth = depth.clone();
7555 if inlined {
7556 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7557 inner_offset = next_offset;
7558 } else {
7559 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7560 inner_depth.increment()?;
7561 }
7562 let val_ref = self.current_value.get_or_insert_with(|| fidl::new_empty!(u8, D));
7563 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7564 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7565 {
7566 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7567 }
7568 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7569 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7570 }
7571 }
7572
7573 next_offset += envelope_size;
7574
7575 while next_offset < end_offset {
7577 _next_ordinal_to_read += 1;
7578 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7579 next_offset += envelope_size;
7580 }
7581
7582 Ok(())
7583 }
7584 }
7585
7586 impl FolderItem {
7587 #[inline(always)]
7588 fn max_ordinal_present(&self) -> u64 {
7589 if let Some(_) = self.displayable_name {
7590 return 4;
7591 }
7592 if let Some(_) = self.is_playable {
7593 return 3;
7594 }
7595 if let Some(_) = self.folder_type {
7596 return 2;
7597 }
7598 if let Some(_) = self.folder_uid {
7599 return 1;
7600 }
7601 0
7602 }
7603 }
7604
7605 impl fidl::encoding::ValueTypeMarker for FolderItem {
7606 type Borrowed<'a> = &'a Self;
7607 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7608 value
7609 }
7610 }
7611
7612 unsafe impl fidl::encoding::TypeMarker for FolderItem {
7613 type Owned = Self;
7614
7615 #[inline(always)]
7616 fn inline_align(_context: fidl::encoding::Context) -> usize {
7617 8
7618 }
7619
7620 #[inline(always)]
7621 fn inline_size(_context: fidl::encoding::Context) -> usize {
7622 16
7623 }
7624 }
7625
7626 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FolderItem, D>
7627 for &FolderItem
7628 {
7629 unsafe fn encode(
7630 self,
7631 encoder: &mut fidl::encoding::Encoder<'_, D>,
7632 offset: usize,
7633 mut depth: fidl::encoding::Depth,
7634 ) -> fidl::Result<()> {
7635 encoder.debug_check_bounds::<FolderItem>(offset);
7636 let max_ordinal: u64 = self.max_ordinal_present();
7638 encoder.write_num(max_ordinal, offset);
7639 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7640 if max_ordinal == 0 {
7642 return Ok(());
7643 }
7644 depth.increment()?;
7645 let envelope_size = 8;
7646 let bytes_len = max_ordinal as usize * envelope_size;
7647 #[allow(unused_variables)]
7648 let offset = encoder.out_of_line_offset(bytes_len);
7649 let mut _prev_end_offset: usize = 0;
7650 if 1 > max_ordinal {
7651 return Ok(());
7652 }
7653
7654 let cur_offset: usize = (1 - 1) * envelope_size;
7657
7658 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7660
7661 fidl::encoding::encode_in_envelope_optional::<u64, D>(
7666 self.folder_uid.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7667 encoder,
7668 offset + cur_offset,
7669 depth,
7670 )?;
7671
7672 _prev_end_offset = cur_offset + envelope_size;
7673 if 2 > max_ordinal {
7674 return Ok(());
7675 }
7676
7677 let cur_offset: usize = (2 - 1) * envelope_size;
7680
7681 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7683
7684 fidl::encoding::encode_in_envelope_optional::<FolderType, D>(
7689 self.folder_type
7690 .as_ref()
7691 .map(<FolderType as fidl::encoding::ValueTypeMarker>::borrow),
7692 encoder,
7693 offset + cur_offset,
7694 depth,
7695 )?;
7696
7697 _prev_end_offset = cur_offset + envelope_size;
7698 if 3 > max_ordinal {
7699 return Ok(());
7700 }
7701
7702 let cur_offset: usize = (3 - 1) * envelope_size;
7705
7706 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7708
7709 fidl::encoding::encode_in_envelope_optional::<bool, D>(
7714 self.is_playable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
7715 encoder,
7716 offset + cur_offset,
7717 depth,
7718 )?;
7719
7720 _prev_end_offset = cur_offset + envelope_size;
7721 if 4 > max_ordinal {
7722 return Ok(());
7723 }
7724
7725 let cur_offset: usize = (4 - 1) * envelope_size;
7728
7729 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7731
7732 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
7737 self.displayable_name.as_ref().map(
7738 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
7739 ),
7740 encoder,
7741 offset + cur_offset,
7742 depth,
7743 )?;
7744
7745 _prev_end_offset = cur_offset + envelope_size;
7746
7747 Ok(())
7748 }
7749 }
7750
7751 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FolderItem {
7752 #[inline(always)]
7753 fn new_empty() -> Self {
7754 Self::default()
7755 }
7756
7757 unsafe fn decode(
7758 &mut self,
7759 decoder: &mut fidl::encoding::Decoder<'_, D>,
7760 offset: usize,
7761 mut depth: fidl::encoding::Depth,
7762 ) -> fidl::Result<()> {
7763 decoder.debug_check_bounds::<Self>(offset);
7764 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7765 None => return Err(fidl::Error::NotNullable),
7766 Some(len) => len,
7767 };
7768 if len == 0 {
7770 return Ok(());
7771 };
7772 depth.increment()?;
7773 let envelope_size = 8;
7774 let bytes_len = len * envelope_size;
7775 let offset = decoder.out_of_line_offset(bytes_len)?;
7776 let mut _next_ordinal_to_read = 0;
7778 let mut next_offset = offset;
7779 let end_offset = offset + bytes_len;
7780 _next_ordinal_to_read += 1;
7781 if next_offset >= end_offset {
7782 return Ok(());
7783 }
7784
7785 while _next_ordinal_to_read < 1 {
7787 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7788 _next_ordinal_to_read += 1;
7789 next_offset += envelope_size;
7790 }
7791
7792 let next_out_of_line = decoder.next_out_of_line();
7793 let handles_before = decoder.remaining_handles();
7794 if let Some((inlined, num_bytes, num_handles)) =
7795 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7796 {
7797 let member_inline_size =
7798 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7799 if inlined != (member_inline_size <= 4) {
7800 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7801 }
7802 let inner_offset;
7803 let mut inner_depth = depth.clone();
7804 if inlined {
7805 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7806 inner_offset = next_offset;
7807 } else {
7808 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7809 inner_depth.increment()?;
7810 }
7811 let val_ref = self.folder_uid.get_or_insert_with(|| fidl::new_empty!(u64, D));
7812 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7813 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7814 {
7815 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7816 }
7817 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7818 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7819 }
7820 }
7821
7822 next_offset += envelope_size;
7823 _next_ordinal_to_read += 1;
7824 if next_offset >= end_offset {
7825 return Ok(());
7826 }
7827
7828 while _next_ordinal_to_read < 2 {
7830 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7831 _next_ordinal_to_read += 1;
7832 next_offset += envelope_size;
7833 }
7834
7835 let next_out_of_line = decoder.next_out_of_line();
7836 let handles_before = decoder.remaining_handles();
7837 if let Some((inlined, num_bytes, num_handles)) =
7838 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7839 {
7840 let member_inline_size =
7841 <FolderType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7842 if inlined != (member_inline_size <= 4) {
7843 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7844 }
7845 let inner_offset;
7846 let mut inner_depth = depth.clone();
7847 if inlined {
7848 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7849 inner_offset = next_offset;
7850 } else {
7851 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7852 inner_depth.increment()?;
7853 }
7854 let val_ref =
7855 self.folder_type.get_or_insert_with(|| fidl::new_empty!(FolderType, D));
7856 fidl::decode!(FolderType, D, val_ref, decoder, inner_offset, inner_depth)?;
7857 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7858 {
7859 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7860 }
7861 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7862 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7863 }
7864 }
7865
7866 next_offset += envelope_size;
7867 _next_ordinal_to_read += 1;
7868 if next_offset >= end_offset {
7869 return Ok(());
7870 }
7871
7872 while _next_ordinal_to_read < 3 {
7874 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7875 _next_ordinal_to_read += 1;
7876 next_offset += envelope_size;
7877 }
7878
7879 let next_out_of_line = decoder.next_out_of_line();
7880 let handles_before = decoder.remaining_handles();
7881 if let Some((inlined, num_bytes, num_handles)) =
7882 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7883 {
7884 let member_inline_size =
7885 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7886 if inlined != (member_inline_size <= 4) {
7887 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7888 }
7889 let inner_offset;
7890 let mut inner_depth = depth.clone();
7891 if inlined {
7892 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7893 inner_offset = next_offset;
7894 } else {
7895 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7896 inner_depth.increment()?;
7897 }
7898 let val_ref = self.is_playable.get_or_insert_with(|| fidl::new_empty!(bool, D));
7899 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
7900 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7901 {
7902 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7903 }
7904 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7905 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7906 }
7907 }
7908
7909 next_offset += envelope_size;
7910 _next_ordinal_to_read += 1;
7911 if next_offset >= end_offset {
7912 return Ok(());
7913 }
7914
7915 while _next_ordinal_to_read < 4 {
7917 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7918 _next_ordinal_to_read += 1;
7919 next_offset += envelope_size;
7920 }
7921
7922 let next_out_of_line = decoder.next_out_of_line();
7923 let handles_before = decoder.remaining_handles();
7924 if let Some((inlined, num_bytes, num_handles)) =
7925 fidl::encoding::decode_envelope_header(decoder, next_offset)?
7926 {
7927 let member_inline_size =
7928 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
7929 decoder.context,
7930 );
7931 if inlined != (member_inline_size <= 4) {
7932 return Err(fidl::Error::InvalidInlineBitInEnvelope);
7933 }
7934 let inner_offset;
7935 let mut inner_depth = depth.clone();
7936 if inlined {
7937 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7938 inner_offset = next_offset;
7939 } else {
7940 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7941 inner_depth.increment()?;
7942 }
7943 let val_ref = self
7944 .displayable_name
7945 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
7946 fidl::decode!(
7947 fidl::encoding::BoundedString<255>,
7948 D,
7949 val_ref,
7950 decoder,
7951 inner_offset,
7952 inner_depth
7953 )?;
7954 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7955 {
7956 return Err(fidl::Error::InvalidNumBytesInEnvelope);
7957 }
7958 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7959 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7960 }
7961 }
7962
7963 next_offset += envelope_size;
7964
7965 while next_offset < end_offset {
7967 _next_ordinal_to_read += 1;
7968 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7969 next_offset += envelope_size;
7970 }
7971
7972 Ok(())
7973 }
7974 }
7975
7976 impl MediaAttributes {
7977 #[inline(always)]
7978 fn max_ordinal_present(&self) -> u64 {
7979 if let Some(_) = self.playing_time {
7980 return 7;
7981 }
7982 if let Some(_) = self.genre {
7983 return 6;
7984 }
7985 if let Some(_) = self.total_number_of_tracks {
7986 return 5;
7987 }
7988 if let Some(_) = self.track_number {
7989 return 4;
7990 }
7991 if let Some(_) = self.album_name {
7992 return 3;
7993 }
7994 if let Some(_) = self.artist_name {
7995 return 2;
7996 }
7997 if let Some(_) = self.title {
7998 return 1;
7999 }
8000 0
8001 }
8002 }
8003
8004 impl fidl::encoding::ValueTypeMarker for MediaAttributes {
8005 type Borrowed<'a> = &'a Self;
8006 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8007 value
8008 }
8009 }
8010
8011 unsafe impl fidl::encoding::TypeMarker for MediaAttributes {
8012 type Owned = Self;
8013
8014 #[inline(always)]
8015 fn inline_align(_context: fidl::encoding::Context) -> usize {
8016 8
8017 }
8018
8019 #[inline(always)]
8020 fn inline_size(_context: fidl::encoding::Context) -> usize {
8021 16
8022 }
8023 }
8024
8025 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaAttributes, D>
8026 for &MediaAttributes
8027 {
8028 unsafe fn encode(
8029 self,
8030 encoder: &mut fidl::encoding::Encoder<'_, D>,
8031 offset: usize,
8032 mut depth: fidl::encoding::Depth,
8033 ) -> fidl::Result<()> {
8034 encoder.debug_check_bounds::<MediaAttributes>(offset);
8035 let max_ordinal: u64 = self.max_ordinal_present();
8037 encoder.write_num(max_ordinal, offset);
8038 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8039 if max_ordinal == 0 {
8041 return Ok(());
8042 }
8043 depth.increment()?;
8044 let envelope_size = 8;
8045 let bytes_len = max_ordinal as usize * envelope_size;
8046 #[allow(unused_variables)]
8047 let offset = encoder.out_of_line_offset(bytes_len);
8048 let mut _prev_end_offset: usize = 0;
8049 if 1 > max_ordinal {
8050 return Ok(());
8051 }
8052
8053 let cur_offset: usize = (1 - 1) * envelope_size;
8056
8057 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8059
8060 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8065 self.title.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8066 encoder, offset + cur_offset, depth
8067 )?;
8068
8069 _prev_end_offset = cur_offset + envelope_size;
8070 if 2 > max_ordinal {
8071 return Ok(());
8072 }
8073
8074 let cur_offset: usize = (2 - 1) * envelope_size;
8077
8078 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8080
8081 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8086 self.artist_name.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8087 encoder, offset + cur_offset, depth
8088 )?;
8089
8090 _prev_end_offset = cur_offset + envelope_size;
8091 if 3 > max_ordinal {
8092 return Ok(());
8093 }
8094
8095 let cur_offset: usize = (3 - 1) * envelope_size;
8098
8099 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8101
8102 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8107 self.album_name.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8108 encoder, offset + cur_offset, depth
8109 )?;
8110
8111 _prev_end_offset = cur_offset + envelope_size;
8112 if 4 > max_ordinal {
8113 return Ok(());
8114 }
8115
8116 let cur_offset: usize = (4 - 1) * envelope_size;
8119
8120 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8122
8123 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8128 self.track_number.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8129 encoder, offset + cur_offset, depth
8130 )?;
8131
8132 _prev_end_offset = cur_offset + envelope_size;
8133 if 5 > max_ordinal {
8134 return Ok(());
8135 }
8136
8137 let cur_offset: usize = (5 - 1) * envelope_size;
8140
8141 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8143
8144 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8149 self.total_number_of_tracks.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8150 encoder, offset + cur_offset, depth
8151 )?;
8152
8153 _prev_end_offset = cur_offset + envelope_size;
8154 if 6 > max_ordinal {
8155 return Ok(());
8156 }
8157
8158 let cur_offset: usize = (6 - 1) * envelope_size;
8161
8162 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8164
8165 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8170 self.genre.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8171 encoder, offset + cur_offset, depth
8172 )?;
8173
8174 _prev_end_offset = cur_offset + envelope_size;
8175 if 7 > max_ordinal {
8176 return Ok(());
8177 }
8178
8179 let cur_offset: usize = (7 - 1) * envelope_size;
8182
8183 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8185
8186 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65535>, D>(
8191 self.playing_time.as_ref().map(<fidl::encoding::BoundedString<65535> as fidl::encoding::ValueTypeMarker>::borrow),
8192 encoder, offset + cur_offset, depth
8193 )?;
8194
8195 _prev_end_offset = cur_offset + envelope_size;
8196
8197 Ok(())
8198 }
8199 }
8200
8201 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaAttributes {
8202 #[inline(always)]
8203 fn new_empty() -> Self {
8204 Self::default()
8205 }
8206
8207 unsafe fn decode(
8208 &mut self,
8209 decoder: &mut fidl::encoding::Decoder<'_, D>,
8210 offset: usize,
8211 mut depth: fidl::encoding::Depth,
8212 ) -> fidl::Result<()> {
8213 decoder.debug_check_bounds::<Self>(offset);
8214 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8215 None => return Err(fidl::Error::NotNullable),
8216 Some(len) => len,
8217 };
8218 if len == 0 {
8220 return Ok(());
8221 };
8222 depth.increment()?;
8223 let envelope_size = 8;
8224 let bytes_len = len * envelope_size;
8225 let offset = decoder.out_of_line_offset(bytes_len)?;
8226 let mut _next_ordinal_to_read = 0;
8228 let mut next_offset = offset;
8229 let end_offset = offset + bytes_len;
8230 _next_ordinal_to_read += 1;
8231 if next_offset >= end_offset {
8232 return Ok(());
8233 }
8234
8235 while _next_ordinal_to_read < 1 {
8237 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8238 _next_ordinal_to_read += 1;
8239 next_offset += envelope_size;
8240 }
8241
8242 let next_out_of_line = decoder.next_out_of_line();
8243 let handles_before = decoder.remaining_handles();
8244 if let Some((inlined, num_bytes, num_handles)) =
8245 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8246 {
8247 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8248 if inlined != (member_inline_size <= 4) {
8249 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8250 }
8251 let inner_offset;
8252 let mut inner_depth = depth.clone();
8253 if inlined {
8254 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8255 inner_offset = next_offset;
8256 } else {
8257 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8258 inner_depth.increment()?;
8259 }
8260 let val_ref = self.title.get_or_insert_with(|| {
8261 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8262 });
8263 fidl::decode!(
8264 fidl::encoding::BoundedString<65535>,
8265 D,
8266 val_ref,
8267 decoder,
8268 inner_offset,
8269 inner_depth
8270 )?;
8271 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8272 {
8273 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8274 }
8275 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8276 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8277 }
8278 }
8279
8280 next_offset += envelope_size;
8281 _next_ordinal_to_read += 1;
8282 if next_offset >= end_offset {
8283 return Ok(());
8284 }
8285
8286 while _next_ordinal_to_read < 2 {
8288 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8289 _next_ordinal_to_read += 1;
8290 next_offset += envelope_size;
8291 }
8292
8293 let next_out_of_line = decoder.next_out_of_line();
8294 let handles_before = decoder.remaining_handles();
8295 if let Some((inlined, num_bytes, num_handles)) =
8296 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8297 {
8298 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8299 if inlined != (member_inline_size <= 4) {
8300 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8301 }
8302 let inner_offset;
8303 let mut inner_depth = depth.clone();
8304 if inlined {
8305 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8306 inner_offset = next_offset;
8307 } else {
8308 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8309 inner_depth.increment()?;
8310 }
8311 let val_ref = self.artist_name.get_or_insert_with(|| {
8312 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8313 });
8314 fidl::decode!(
8315 fidl::encoding::BoundedString<65535>,
8316 D,
8317 val_ref,
8318 decoder,
8319 inner_offset,
8320 inner_depth
8321 )?;
8322 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8323 {
8324 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8325 }
8326 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8327 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8328 }
8329 }
8330
8331 next_offset += envelope_size;
8332 _next_ordinal_to_read += 1;
8333 if next_offset >= end_offset {
8334 return Ok(());
8335 }
8336
8337 while _next_ordinal_to_read < 3 {
8339 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8340 _next_ordinal_to_read += 1;
8341 next_offset += envelope_size;
8342 }
8343
8344 let next_out_of_line = decoder.next_out_of_line();
8345 let handles_before = decoder.remaining_handles();
8346 if let Some((inlined, num_bytes, num_handles)) =
8347 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8348 {
8349 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8350 if inlined != (member_inline_size <= 4) {
8351 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8352 }
8353 let inner_offset;
8354 let mut inner_depth = depth.clone();
8355 if inlined {
8356 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8357 inner_offset = next_offset;
8358 } else {
8359 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8360 inner_depth.increment()?;
8361 }
8362 let val_ref = self.album_name.get_or_insert_with(|| {
8363 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8364 });
8365 fidl::decode!(
8366 fidl::encoding::BoundedString<65535>,
8367 D,
8368 val_ref,
8369 decoder,
8370 inner_offset,
8371 inner_depth
8372 )?;
8373 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8374 {
8375 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8376 }
8377 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8378 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8379 }
8380 }
8381
8382 next_offset += envelope_size;
8383 _next_ordinal_to_read += 1;
8384 if next_offset >= end_offset {
8385 return Ok(());
8386 }
8387
8388 while _next_ordinal_to_read < 4 {
8390 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8391 _next_ordinal_to_read += 1;
8392 next_offset += envelope_size;
8393 }
8394
8395 let next_out_of_line = decoder.next_out_of_line();
8396 let handles_before = decoder.remaining_handles();
8397 if let Some((inlined, num_bytes, num_handles)) =
8398 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8399 {
8400 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8401 if inlined != (member_inline_size <= 4) {
8402 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8403 }
8404 let inner_offset;
8405 let mut inner_depth = depth.clone();
8406 if inlined {
8407 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8408 inner_offset = next_offset;
8409 } else {
8410 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8411 inner_depth.increment()?;
8412 }
8413 let val_ref = self.track_number.get_or_insert_with(|| {
8414 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8415 });
8416 fidl::decode!(
8417 fidl::encoding::BoundedString<65535>,
8418 D,
8419 val_ref,
8420 decoder,
8421 inner_offset,
8422 inner_depth
8423 )?;
8424 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8425 {
8426 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8427 }
8428 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8429 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8430 }
8431 }
8432
8433 next_offset += envelope_size;
8434 _next_ordinal_to_read += 1;
8435 if next_offset >= end_offset {
8436 return Ok(());
8437 }
8438
8439 while _next_ordinal_to_read < 5 {
8441 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8442 _next_ordinal_to_read += 1;
8443 next_offset += envelope_size;
8444 }
8445
8446 let next_out_of_line = decoder.next_out_of_line();
8447 let handles_before = decoder.remaining_handles();
8448 if let Some((inlined, num_bytes, num_handles)) =
8449 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8450 {
8451 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8452 if inlined != (member_inline_size <= 4) {
8453 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8454 }
8455 let inner_offset;
8456 let mut inner_depth = depth.clone();
8457 if inlined {
8458 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8459 inner_offset = next_offset;
8460 } else {
8461 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8462 inner_depth.increment()?;
8463 }
8464 let val_ref = self.total_number_of_tracks.get_or_insert_with(|| {
8465 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8466 });
8467 fidl::decode!(
8468 fidl::encoding::BoundedString<65535>,
8469 D,
8470 val_ref,
8471 decoder,
8472 inner_offset,
8473 inner_depth
8474 )?;
8475 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8476 {
8477 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8478 }
8479 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8480 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8481 }
8482 }
8483
8484 next_offset += envelope_size;
8485 _next_ordinal_to_read += 1;
8486 if next_offset >= end_offset {
8487 return Ok(());
8488 }
8489
8490 while _next_ordinal_to_read < 6 {
8492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8493 _next_ordinal_to_read += 1;
8494 next_offset += envelope_size;
8495 }
8496
8497 let next_out_of_line = decoder.next_out_of_line();
8498 let handles_before = decoder.remaining_handles();
8499 if let Some((inlined, num_bytes, num_handles)) =
8500 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8501 {
8502 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8503 if inlined != (member_inline_size <= 4) {
8504 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8505 }
8506 let inner_offset;
8507 let mut inner_depth = depth.clone();
8508 if inlined {
8509 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8510 inner_offset = next_offset;
8511 } else {
8512 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8513 inner_depth.increment()?;
8514 }
8515 let val_ref = self.genre.get_or_insert_with(|| {
8516 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8517 });
8518 fidl::decode!(
8519 fidl::encoding::BoundedString<65535>,
8520 D,
8521 val_ref,
8522 decoder,
8523 inner_offset,
8524 inner_depth
8525 )?;
8526 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8527 {
8528 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8529 }
8530 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8531 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8532 }
8533 }
8534
8535 next_offset += envelope_size;
8536 _next_ordinal_to_read += 1;
8537 if next_offset >= end_offset {
8538 return Ok(());
8539 }
8540
8541 while _next_ordinal_to_read < 7 {
8543 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8544 _next_ordinal_to_read += 1;
8545 next_offset += envelope_size;
8546 }
8547
8548 let next_out_of_line = decoder.next_out_of_line();
8549 let handles_before = decoder.remaining_handles();
8550 if let Some((inlined, num_bytes, num_handles)) =
8551 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8552 {
8553 let member_inline_size = <fidl::encoding::BoundedString<65535> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8554 if inlined != (member_inline_size <= 4) {
8555 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8556 }
8557 let inner_offset;
8558 let mut inner_depth = depth.clone();
8559 if inlined {
8560 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8561 inner_offset = next_offset;
8562 } else {
8563 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8564 inner_depth.increment()?;
8565 }
8566 let val_ref = self.playing_time.get_or_insert_with(|| {
8567 fidl::new_empty!(fidl::encoding::BoundedString<65535>, D)
8568 });
8569 fidl::decode!(
8570 fidl::encoding::BoundedString<65535>,
8571 D,
8572 val_ref,
8573 decoder,
8574 inner_offset,
8575 inner_depth
8576 )?;
8577 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8578 {
8579 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8580 }
8581 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8582 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8583 }
8584 }
8585
8586 next_offset += envelope_size;
8587
8588 while next_offset < end_offset {
8590 _next_ordinal_to_read += 1;
8591 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8592 next_offset += envelope_size;
8593 }
8594
8595 Ok(())
8596 }
8597 }
8598
8599 impl MediaElementItem {
8600 #[inline(always)]
8601 fn max_ordinal_present(&self) -> u64 {
8602 if let Some(_) = self.attributes {
8603 return 4;
8604 }
8605 if let Some(_) = self.displayable_name {
8606 return 3;
8607 }
8608 if let Some(_) = self.media_type {
8609 return 2;
8610 }
8611 if let Some(_) = self.media_element_uid {
8612 return 1;
8613 }
8614 0
8615 }
8616 }
8617
8618 impl fidl::encoding::ValueTypeMarker for MediaElementItem {
8619 type Borrowed<'a> = &'a Self;
8620 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8621 value
8622 }
8623 }
8624
8625 unsafe impl fidl::encoding::TypeMarker for MediaElementItem {
8626 type Owned = Self;
8627
8628 #[inline(always)]
8629 fn inline_align(_context: fidl::encoding::Context) -> usize {
8630 8
8631 }
8632
8633 #[inline(always)]
8634 fn inline_size(_context: fidl::encoding::Context) -> usize {
8635 16
8636 }
8637 }
8638
8639 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaElementItem, D>
8640 for &MediaElementItem
8641 {
8642 unsafe fn encode(
8643 self,
8644 encoder: &mut fidl::encoding::Encoder<'_, D>,
8645 offset: usize,
8646 mut depth: fidl::encoding::Depth,
8647 ) -> fidl::Result<()> {
8648 encoder.debug_check_bounds::<MediaElementItem>(offset);
8649 let max_ordinal: u64 = self.max_ordinal_present();
8651 encoder.write_num(max_ordinal, offset);
8652 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8653 if max_ordinal == 0 {
8655 return Ok(());
8656 }
8657 depth.increment()?;
8658 let envelope_size = 8;
8659 let bytes_len = max_ordinal as usize * envelope_size;
8660 #[allow(unused_variables)]
8661 let offset = encoder.out_of_line_offset(bytes_len);
8662 let mut _prev_end_offset: usize = 0;
8663 if 1 > max_ordinal {
8664 return Ok(());
8665 }
8666
8667 let cur_offset: usize = (1 - 1) * envelope_size;
8670
8671 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8673
8674 fidl::encoding::encode_in_envelope_optional::<u64, D>(
8679 self.media_element_uid
8680 .as_ref()
8681 .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8682 encoder,
8683 offset + cur_offset,
8684 depth,
8685 )?;
8686
8687 _prev_end_offset = cur_offset + envelope_size;
8688 if 2 > max_ordinal {
8689 return Ok(());
8690 }
8691
8692 let cur_offset: usize = (2 - 1) * envelope_size;
8695
8696 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8698
8699 fidl::encoding::encode_in_envelope_optional::<MediaType, D>(
8704 self.media_type
8705 .as_ref()
8706 .map(<MediaType as fidl::encoding::ValueTypeMarker>::borrow),
8707 encoder,
8708 offset + cur_offset,
8709 depth,
8710 )?;
8711
8712 _prev_end_offset = cur_offset + envelope_size;
8713 if 3 > max_ordinal {
8714 return Ok(());
8715 }
8716
8717 let cur_offset: usize = (3 - 1) * envelope_size;
8720
8721 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8723
8724 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
8729 self.displayable_name.as_ref().map(
8730 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
8731 ),
8732 encoder,
8733 offset + cur_offset,
8734 depth,
8735 )?;
8736
8737 _prev_end_offset = cur_offset + envelope_size;
8738 if 4 > max_ordinal {
8739 return Ok(());
8740 }
8741
8742 let cur_offset: usize = (4 - 1) * envelope_size;
8745
8746 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8748
8749 fidl::encoding::encode_in_envelope_optional::<MediaAttributes, D>(
8754 self.attributes
8755 .as_ref()
8756 .map(<MediaAttributes as fidl::encoding::ValueTypeMarker>::borrow),
8757 encoder,
8758 offset + cur_offset,
8759 depth,
8760 )?;
8761
8762 _prev_end_offset = cur_offset + envelope_size;
8763
8764 Ok(())
8765 }
8766 }
8767
8768 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaElementItem {
8769 #[inline(always)]
8770 fn new_empty() -> Self {
8771 Self::default()
8772 }
8773
8774 unsafe fn decode(
8775 &mut self,
8776 decoder: &mut fidl::encoding::Decoder<'_, D>,
8777 offset: usize,
8778 mut depth: fidl::encoding::Depth,
8779 ) -> fidl::Result<()> {
8780 decoder.debug_check_bounds::<Self>(offset);
8781 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8782 None => return Err(fidl::Error::NotNullable),
8783 Some(len) => len,
8784 };
8785 if len == 0 {
8787 return Ok(());
8788 };
8789 depth.increment()?;
8790 let envelope_size = 8;
8791 let bytes_len = len * envelope_size;
8792 let offset = decoder.out_of_line_offset(bytes_len)?;
8793 let mut _next_ordinal_to_read = 0;
8795 let mut next_offset = offset;
8796 let end_offset = offset + bytes_len;
8797 _next_ordinal_to_read += 1;
8798 if next_offset >= end_offset {
8799 return Ok(());
8800 }
8801
8802 while _next_ordinal_to_read < 1 {
8804 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8805 _next_ordinal_to_read += 1;
8806 next_offset += envelope_size;
8807 }
8808
8809 let next_out_of_line = decoder.next_out_of_line();
8810 let handles_before = decoder.remaining_handles();
8811 if let Some((inlined, num_bytes, num_handles)) =
8812 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8813 {
8814 let member_inline_size =
8815 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8816 if inlined != (member_inline_size <= 4) {
8817 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8818 }
8819 let inner_offset;
8820 let mut inner_depth = depth.clone();
8821 if inlined {
8822 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8823 inner_offset = next_offset;
8824 } else {
8825 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8826 inner_depth.increment()?;
8827 }
8828 let val_ref =
8829 self.media_element_uid.get_or_insert_with(|| fidl::new_empty!(u64, D));
8830 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8831 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8832 {
8833 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8834 }
8835 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8836 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8837 }
8838 }
8839
8840 next_offset += envelope_size;
8841 _next_ordinal_to_read += 1;
8842 if next_offset >= end_offset {
8843 return Ok(());
8844 }
8845
8846 while _next_ordinal_to_read < 2 {
8848 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8849 _next_ordinal_to_read += 1;
8850 next_offset += envelope_size;
8851 }
8852
8853 let next_out_of_line = decoder.next_out_of_line();
8854 let handles_before = decoder.remaining_handles();
8855 if let Some((inlined, num_bytes, num_handles)) =
8856 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8857 {
8858 let member_inline_size =
8859 <MediaType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8860 if inlined != (member_inline_size <= 4) {
8861 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8862 }
8863 let inner_offset;
8864 let mut inner_depth = depth.clone();
8865 if inlined {
8866 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8867 inner_offset = next_offset;
8868 } else {
8869 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8870 inner_depth.increment()?;
8871 }
8872 let val_ref = self.media_type.get_or_insert_with(|| fidl::new_empty!(MediaType, D));
8873 fidl::decode!(MediaType, D, val_ref, decoder, inner_offset, inner_depth)?;
8874 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8875 {
8876 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8877 }
8878 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8879 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8880 }
8881 }
8882
8883 next_offset += envelope_size;
8884 _next_ordinal_to_read += 1;
8885 if next_offset >= end_offset {
8886 return Ok(());
8887 }
8888
8889 while _next_ordinal_to_read < 3 {
8891 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8892 _next_ordinal_to_read += 1;
8893 next_offset += envelope_size;
8894 }
8895
8896 let next_out_of_line = decoder.next_out_of_line();
8897 let handles_before = decoder.remaining_handles();
8898 if let Some((inlined, num_bytes, num_handles)) =
8899 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8900 {
8901 let member_inline_size =
8902 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
8903 decoder.context,
8904 );
8905 if inlined != (member_inline_size <= 4) {
8906 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8907 }
8908 let inner_offset;
8909 let mut inner_depth = depth.clone();
8910 if inlined {
8911 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8912 inner_offset = next_offset;
8913 } else {
8914 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8915 inner_depth.increment()?;
8916 }
8917 let val_ref = self
8918 .displayable_name
8919 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
8920 fidl::decode!(
8921 fidl::encoding::BoundedString<255>,
8922 D,
8923 val_ref,
8924 decoder,
8925 inner_offset,
8926 inner_depth
8927 )?;
8928 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8929 {
8930 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8931 }
8932 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8933 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8934 }
8935 }
8936
8937 next_offset += envelope_size;
8938 _next_ordinal_to_read += 1;
8939 if next_offset >= end_offset {
8940 return Ok(());
8941 }
8942
8943 while _next_ordinal_to_read < 4 {
8945 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8946 _next_ordinal_to_read += 1;
8947 next_offset += envelope_size;
8948 }
8949
8950 let next_out_of_line = decoder.next_out_of_line();
8951 let handles_before = decoder.remaining_handles();
8952 if let Some((inlined, num_bytes, num_handles)) =
8953 fidl::encoding::decode_envelope_header(decoder, next_offset)?
8954 {
8955 let member_inline_size =
8956 <MediaAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8957 if inlined != (member_inline_size <= 4) {
8958 return Err(fidl::Error::InvalidInlineBitInEnvelope);
8959 }
8960 let inner_offset;
8961 let mut inner_depth = depth.clone();
8962 if inlined {
8963 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8964 inner_offset = next_offset;
8965 } else {
8966 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8967 inner_depth.increment()?;
8968 }
8969 let val_ref =
8970 self.attributes.get_or_insert_with(|| fidl::new_empty!(MediaAttributes, D));
8971 fidl::decode!(MediaAttributes, D, val_ref, decoder, inner_offset, inner_depth)?;
8972 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8973 {
8974 return Err(fidl::Error::InvalidNumBytesInEnvelope);
8975 }
8976 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8977 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8978 }
8979 }
8980
8981 next_offset += envelope_size;
8982
8983 while next_offset < end_offset {
8985 _next_ordinal_to_read += 1;
8986 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8987 next_offset += envelope_size;
8988 }
8989
8990 Ok(())
8991 }
8992 }
8993
8994 impl MediaPlayerItem {
8995 #[inline(always)]
8996 fn max_ordinal_present(&self) -> u64 {
8997 if let Some(_) = self.feature_bits_ext {
8998 return 7;
8999 }
9000 if let Some(_) = self.feature_bits {
9001 return 6;
9002 }
9003 if let Some(_) = self.displayable_name {
9004 return 5;
9005 }
9006 if let Some(_) = self.playback_status {
9007 return 4;
9008 }
9009 if let Some(_) = self.sub_type {
9010 return 3;
9011 }
9012 if let Some(_) = self.major_type {
9013 return 2;
9014 }
9015 if let Some(_) = self.player_id {
9016 return 1;
9017 }
9018 0
9019 }
9020 }
9021
9022 impl fidl::encoding::ValueTypeMarker for MediaPlayerItem {
9023 type Borrowed<'a> = &'a Self;
9024 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9025 value
9026 }
9027 }
9028
9029 unsafe impl fidl::encoding::TypeMarker for MediaPlayerItem {
9030 type Owned = Self;
9031
9032 #[inline(always)]
9033 fn inline_align(_context: fidl::encoding::Context) -> usize {
9034 8
9035 }
9036
9037 #[inline(always)]
9038 fn inline_size(_context: fidl::encoding::Context) -> usize {
9039 16
9040 }
9041 }
9042
9043 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MediaPlayerItem, D>
9044 for &MediaPlayerItem
9045 {
9046 unsafe fn encode(
9047 self,
9048 encoder: &mut fidl::encoding::Encoder<'_, D>,
9049 offset: usize,
9050 mut depth: fidl::encoding::Depth,
9051 ) -> fidl::Result<()> {
9052 encoder.debug_check_bounds::<MediaPlayerItem>(offset);
9053 let max_ordinal: u64 = self.max_ordinal_present();
9055 encoder.write_num(max_ordinal, offset);
9056 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9057 if max_ordinal == 0 {
9059 return Ok(());
9060 }
9061 depth.increment()?;
9062 let envelope_size = 8;
9063 let bytes_len = max_ordinal as usize * envelope_size;
9064 #[allow(unused_variables)]
9065 let offset = encoder.out_of_line_offset(bytes_len);
9066 let mut _prev_end_offset: usize = 0;
9067 if 1 > max_ordinal {
9068 return Ok(());
9069 }
9070
9071 let cur_offset: usize = (1 - 1) * envelope_size;
9074
9075 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9077
9078 fidl::encoding::encode_in_envelope_optional::<u16, D>(
9083 self.player_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9084 encoder,
9085 offset + cur_offset,
9086 depth,
9087 )?;
9088
9089 _prev_end_offset = cur_offset + envelope_size;
9090 if 2 > max_ordinal {
9091 return Ok(());
9092 }
9093
9094 let cur_offset: usize = (2 - 1) * envelope_size;
9097
9098 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9100
9101 fidl::encoding::encode_in_envelope_optional::<MajorPlayerType, D>(
9106 self.major_type
9107 .as_ref()
9108 .map(<MajorPlayerType as fidl::encoding::ValueTypeMarker>::borrow),
9109 encoder,
9110 offset + cur_offset,
9111 depth,
9112 )?;
9113
9114 _prev_end_offset = cur_offset + envelope_size;
9115 if 3 > max_ordinal {
9116 return Ok(());
9117 }
9118
9119 let cur_offset: usize = (3 - 1) * envelope_size;
9122
9123 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9125
9126 fidl::encoding::encode_in_envelope_optional::<PlayerSubType, D>(
9131 self.sub_type
9132 .as_ref()
9133 .map(<PlayerSubType as fidl::encoding::ValueTypeMarker>::borrow),
9134 encoder,
9135 offset + cur_offset,
9136 depth,
9137 )?;
9138
9139 _prev_end_offset = cur_offset + envelope_size;
9140 if 4 > max_ordinal {
9141 return Ok(());
9142 }
9143
9144 let cur_offset: usize = (4 - 1) * envelope_size;
9147
9148 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9150
9151 fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
9156 self.playback_status
9157 .as_ref()
9158 .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
9159 encoder,
9160 offset + cur_offset,
9161 depth,
9162 )?;
9163
9164 _prev_end_offset = cur_offset + envelope_size;
9165 if 5 > max_ordinal {
9166 return Ok(());
9167 }
9168
9169 let cur_offset: usize = (5 - 1) * envelope_size;
9172
9173 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9175
9176 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
9181 self.displayable_name.as_ref().map(
9182 <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
9183 ),
9184 encoder,
9185 offset + cur_offset,
9186 depth,
9187 )?;
9188
9189 _prev_end_offset = cur_offset + envelope_size;
9190 if 6 > max_ordinal {
9191 return Ok(());
9192 }
9193
9194 let cur_offset: usize = (6 - 1) * envelope_size;
9197
9198 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9200
9201 fidl::encoding::encode_in_envelope_optional::<PlayerFeatureBits, D>(
9206 self.feature_bits
9207 .as_ref()
9208 .map(<PlayerFeatureBits as fidl::encoding::ValueTypeMarker>::borrow),
9209 encoder,
9210 offset + cur_offset,
9211 depth,
9212 )?;
9213
9214 _prev_end_offset = cur_offset + envelope_size;
9215 if 7 > max_ordinal {
9216 return Ok(());
9217 }
9218
9219 let cur_offset: usize = (7 - 1) * envelope_size;
9222
9223 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9225
9226 fidl::encoding::encode_in_envelope_optional::<PlayerFeatureBitsExt, D>(
9231 self.feature_bits_ext
9232 .as_ref()
9233 .map(<PlayerFeatureBitsExt as fidl::encoding::ValueTypeMarker>::borrow),
9234 encoder,
9235 offset + cur_offset,
9236 depth,
9237 )?;
9238
9239 _prev_end_offset = cur_offset + envelope_size;
9240
9241 Ok(())
9242 }
9243 }
9244
9245 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MediaPlayerItem {
9246 #[inline(always)]
9247 fn new_empty() -> Self {
9248 Self::default()
9249 }
9250
9251 unsafe fn decode(
9252 &mut self,
9253 decoder: &mut fidl::encoding::Decoder<'_, D>,
9254 offset: usize,
9255 mut depth: fidl::encoding::Depth,
9256 ) -> fidl::Result<()> {
9257 decoder.debug_check_bounds::<Self>(offset);
9258 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9259 None => return Err(fidl::Error::NotNullable),
9260 Some(len) => len,
9261 };
9262 if len == 0 {
9264 return Ok(());
9265 };
9266 depth.increment()?;
9267 let envelope_size = 8;
9268 let bytes_len = len * envelope_size;
9269 let offset = decoder.out_of_line_offset(bytes_len)?;
9270 let mut _next_ordinal_to_read = 0;
9272 let mut next_offset = offset;
9273 let end_offset = offset + bytes_len;
9274 _next_ordinal_to_read += 1;
9275 if next_offset >= end_offset {
9276 return Ok(());
9277 }
9278
9279 while _next_ordinal_to_read < 1 {
9281 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9282 _next_ordinal_to_read += 1;
9283 next_offset += envelope_size;
9284 }
9285
9286 let next_out_of_line = decoder.next_out_of_line();
9287 let handles_before = decoder.remaining_handles();
9288 if let Some((inlined, num_bytes, num_handles)) =
9289 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9290 {
9291 let member_inline_size =
9292 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9293 if inlined != (member_inline_size <= 4) {
9294 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9295 }
9296 let inner_offset;
9297 let mut inner_depth = depth.clone();
9298 if inlined {
9299 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9300 inner_offset = next_offset;
9301 } else {
9302 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9303 inner_depth.increment()?;
9304 }
9305 let val_ref = self.player_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9306 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9307 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9308 {
9309 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9310 }
9311 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9312 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9313 }
9314 }
9315
9316 next_offset += envelope_size;
9317 _next_ordinal_to_read += 1;
9318 if next_offset >= end_offset {
9319 return Ok(());
9320 }
9321
9322 while _next_ordinal_to_read < 2 {
9324 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9325 _next_ordinal_to_read += 1;
9326 next_offset += envelope_size;
9327 }
9328
9329 let next_out_of_line = decoder.next_out_of_line();
9330 let handles_before = decoder.remaining_handles();
9331 if let Some((inlined, num_bytes, num_handles)) =
9332 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9333 {
9334 let member_inline_size =
9335 <MajorPlayerType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9336 if inlined != (member_inline_size <= 4) {
9337 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9338 }
9339 let inner_offset;
9340 let mut inner_depth = depth.clone();
9341 if inlined {
9342 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9343 inner_offset = next_offset;
9344 } else {
9345 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9346 inner_depth.increment()?;
9347 }
9348 let val_ref =
9349 self.major_type.get_or_insert_with(|| fidl::new_empty!(MajorPlayerType, D));
9350 fidl::decode!(MajorPlayerType, D, val_ref, decoder, inner_offset, inner_depth)?;
9351 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9352 {
9353 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9354 }
9355 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9356 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9357 }
9358 }
9359
9360 next_offset += envelope_size;
9361 _next_ordinal_to_read += 1;
9362 if next_offset >= end_offset {
9363 return Ok(());
9364 }
9365
9366 while _next_ordinal_to_read < 3 {
9368 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9369 _next_ordinal_to_read += 1;
9370 next_offset += envelope_size;
9371 }
9372
9373 let next_out_of_line = decoder.next_out_of_line();
9374 let handles_before = decoder.remaining_handles();
9375 if let Some((inlined, num_bytes, num_handles)) =
9376 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9377 {
9378 let member_inline_size =
9379 <PlayerSubType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9380 if inlined != (member_inline_size <= 4) {
9381 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9382 }
9383 let inner_offset;
9384 let mut inner_depth = depth.clone();
9385 if inlined {
9386 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9387 inner_offset = next_offset;
9388 } else {
9389 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9390 inner_depth.increment()?;
9391 }
9392 let val_ref =
9393 self.sub_type.get_or_insert_with(|| fidl::new_empty!(PlayerSubType, D));
9394 fidl::decode!(PlayerSubType, D, val_ref, decoder, inner_offset, inner_depth)?;
9395 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9396 {
9397 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9398 }
9399 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9400 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9401 }
9402 }
9403
9404 next_offset += envelope_size;
9405 _next_ordinal_to_read += 1;
9406 if next_offset >= end_offset {
9407 return Ok(());
9408 }
9409
9410 while _next_ordinal_to_read < 4 {
9412 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9413 _next_ordinal_to_read += 1;
9414 next_offset += envelope_size;
9415 }
9416
9417 let next_out_of_line = decoder.next_out_of_line();
9418 let handles_before = decoder.remaining_handles();
9419 if let Some((inlined, num_bytes, num_handles)) =
9420 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9421 {
9422 let member_inline_size =
9423 <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9424 if inlined != (member_inline_size <= 4) {
9425 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9426 }
9427 let inner_offset;
9428 let mut inner_depth = depth.clone();
9429 if inlined {
9430 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9431 inner_offset = next_offset;
9432 } else {
9433 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9434 inner_depth.increment()?;
9435 }
9436 let val_ref =
9437 self.playback_status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
9438 fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
9439 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9440 {
9441 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9442 }
9443 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9444 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9445 }
9446 }
9447
9448 next_offset += envelope_size;
9449 _next_ordinal_to_read += 1;
9450 if next_offset >= end_offset {
9451 return Ok(());
9452 }
9453
9454 while _next_ordinal_to_read < 5 {
9456 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9457 _next_ordinal_to_read += 1;
9458 next_offset += envelope_size;
9459 }
9460
9461 let next_out_of_line = decoder.next_out_of_line();
9462 let handles_before = decoder.remaining_handles();
9463 if let Some((inlined, num_bytes, num_handles)) =
9464 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9465 {
9466 let member_inline_size =
9467 <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
9468 decoder.context,
9469 );
9470 if inlined != (member_inline_size <= 4) {
9471 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9472 }
9473 let inner_offset;
9474 let mut inner_depth = depth.clone();
9475 if inlined {
9476 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9477 inner_offset = next_offset;
9478 } else {
9479 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9480 inner_depth.increment()?;
9481 }
9482 let val_ref = self
9483 .displayable_name
9484 .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
9485 fidl::decode!(
9486 fidl::encoding::BoundedString<255>,
9487 D,
9488 val_ref,
9489 decoder,
9490 inner_offset,
9491 inner_depth
9492 )?;
9493 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9494 {
9495 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9496 }
9497 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9498 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9499 }
9500 }
9501
9502 next_offset += envelope_size;
9503 _next_ordinal_to_read += 1;
9504 if next_offset >= end_offset {
9505 return Ok(());
9506 }
9507
9508 while _next_ordinal_to_read < 6 {
9510 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9511 _next_ordinal_to_read += 1;
9512 next_offset += envelope_size;
9513 }
9514
9515 let next_out_of_line = decoder.next_out_of_line();
9516 let handles_before = decoder.remaining_handles();
9517 if let Some((inlined, num_bytes, num_handles)) =
9518 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9519 {
9520 let member_inline_size =
9521 <PlayerFeatureBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9522 if inlined != (member_inline_size <= 4) {
9523 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9524 }
9525 let inner_offset;
9526 let mut inner_depth = depth.clone();
9527 if inlined {
9528 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9529 inner_offset = next_offset;
9530 } else {
9531 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9532 inner_depth.increment()?;
9533 }
9534 let val_ref =
9535 self.feature_bits.get_or_insert_with(|| fidl::new_empty!(PlayerFeatureBits, D));
9536 fidl::decode!(PlayerFeatureBits, D, val_ref, decoder, inner_offset, inner_depth)?;
9537 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9538 {
9539 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9540 }
9541 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9542 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9543 }
9544 }
9545
9546 next_offset += envelope_size;
9547 _next_ordinal_to_read += 1;
9548 if next_offset >= end_offset {
9549 return Ok(());
9550 }
9551
9552 while _next_ordinal_to_read < 7 {
9554 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9555 _next_ordinal_to_read += 1;
9556 next_offset += envelope_size;
9557 }
9558
9559 let next_out_of_line = decoder.next_out_of_line();
9560 let handles_before = decoder.remaining_handles();
9561 if let Some((inlined, num_bytes, num_handles)) =
9562 fidl::encoding::decode_envelope_header(decoder, next_offset)?
9563 {
9564 let member_inline_size =
9565 <PlayerFeatureBitsExt as fidl::encoding::TypeMarker>::inline_size(
9566 decoder.context,
9567 );
9568 if inlined != (member_inline_size <= 4) {
9569 return Err(fidl::Error::InvalidInlineBitInEnvelope);
9570 }
9571 let inner_offset;
9572 let mut inner_depth = depth.clone();
9573 if inlined {
9574 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9575 inner_offset = next_offset;
9576 } else {
9577 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9578 inner_depth.increment()?;
9579 }
9580 let val_ref = self
9581 .feature_bits_ext
9582 .get_or_insert_with(|| fidl::new_empty!(PlayerFeatureBitsExt, D));
9583 fidl::decode!(
9584 PlayerFeatureBitsExt,
9585 D,
9586 val_ref,
9587 decoder,
9588 inner_offset,
9589 inner_depth
9590 )?;
9591 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9592 {
9593 return Err(fidl::Error::InvalidNumBytesInEnvelope);
9594 }
9595 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9596 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9597 }
9598 }
9599
9600 next_offset += envelope_size;
9601
9602 while next_offset < end_offset {
9604 _next_ordinal_to_read += 1;
9605 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9606 next_offset += envelope_size;
9607 }
9608
9609 Ok(())
9610 }
9611 }
9612
9613 impl Notification {
9614 #[inline(always)]
9615 fn max_ordinal_present(&self) -> u64 {
9616 if let Some(_) = self.addressed_player {
9617 return 11;
9618 }
9619 if let Some(_) = self.available_players_changed {
9620 return 10;
9621 }
9622 if let Some(_) = self.device_connected {
9623 return 9;
9624 }
9625 if let Some(_) = self.volume {
9626 return 8;
9627 }
9628 if let Some(_) = self.player_id {
9629 return 7;
9630 }
9631 if let Some(_) = self.application_settings {
9632 return 6;
9633 }
9634 if let Some(_) = self.system_status {
9635 return 5;
9636 }
9637 if let Some(_) = self.battery_status {
9638 return 4;
9639 }
9640 if let Some(_) = self.pos {
9641 return 3;
9642 }
9643 if let Some(_) = self.track_id {
9644 return 2;
9645 }
9646 if let Some(_) = self.status {
9647 return 1;
9648 }
9649 0
9650 }
9651 }
9652
9653 impl fidl::encoding::ValueTypeMarker for Notification {
9654 type Borrowed<'a> = &'a Self;
9655 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9656 value
9657 }
9658 }
9659
9660 unsafe impl fidl::encoding::TypeMarker for Notification {
9661 type Owned = Self;
9662
9663 #[inline(always)]
9664 fn inline_align(_context: fidl::encoding::Context) -> usize {
9665 8
9666 }
9667
9668 #[inline(always)]
9669 fn inline_size(_context: fidl::encoding::Context) -> usize {
9670 16
9671 }
9672 }
9673
9674 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Notification, D>
9675 for &Notification
9676 {
9677 unsafe fn encode(
9678 self,
9679 encoder: &mut fidl::encoding::Encoder<'_, D>,
9680 offset: usize,
9681 mut depth: fidl::encoding::Depth,
9682 ) -> fidl::Result<()> {
9683 encoder.debug_check_bounds::<Notification>(offset);
9684 let max_ordinal: u64 = self.max_ordinal_present();
9686 encoder.write_num(max_ordinal, offset);
9687 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9688 if max_ordinal == 0 {
9690 return Ok(());
9691 }
9692 depth.increment()?;
9693 let envelope_size = 8;
9694 let bytes_len = max_ordinal as usize * envelope_size;
9695 #[allow(unused_variables)]
9696 let offset = encoder.out_of_line_offset(bytes_len);
9697 let mut _prev_end_offset: usize = 0;
9698 if 1 > max_ordinal {
9699 return Ok(());
9700 }
9701
9702 let cur_offset: usize = (1 - 1) * envelope_size;
9705
9706 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9708
9709 fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
9714 self.status
9715 .as_ref()
9716 .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
9717 encoder,
9718 offset + cur_offset,
9719 depth,
9720 )?;
9721
9722 _prev_end_offset = cur_offset + envelope_size;
9723 if 2 > max_ordinal {
9724 return Ok(());
9725 }
9726
9727 let cur_offset: usize = (2 - 1) * envelope_size;
9730
9731 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9733
9734 fidl::encoding::encode_in_envelope_optional::<u64, D>(
9739 self.track_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9740 encoder,
9741 offset + cur_offset,
9742 depth,
9743 )?;
9744
9745 _prev_end_offset = cur_offset + envelope_size;
9746 if 3 > max_ordinal {
9747 return Ok(());
9748 }
9749
9750 let cur_offset: usize = (3 - 1) * envelope_size;
9753
9754 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9756
9757 fidl::encoding::encode_in_envelope_optional::<u32, D>(
9762 self.pos.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9763 encoder,
9764 offset + cur_offset,
9765 depth,
9766 )?;
9767
9768 _prev_end_offset = cur_offset + envelope_size;
9769 if 4 > max_ordinal {
9770 return Ok(());
9771 }
9772
9773 let cur_offset: usize = (4 - 1) * envelope_size;
9776
9777 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9779
9780 fidl::encoding::encode_in_envelope_optional::<BatteryStatus, D>(
9785 self.battery_status
9786 .as_ref()
9787 .map(<BatteryStatus as fidl::encoding::ValueTypeMarker>::borrow),
9788 encoder,
9789 offset + cur_offset,
9790 depth,
9791 )?;
9792
9793 _prev_end_offset = cur_offset + envelope_size;
9794 if 5 > max_ordinal {
9795 return Ok(());
9796 }
9797
9798 let cur_offset: usize = (5 - 1) * envelope_size;
9801
9802 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9804
9805 fidl::encoding::encode_in_envelope_optional::<SystemStatus, D>(
9810 self.system_status
9811 .as_ref()
9812 .map(<SystemStatus as fidl::encoding::ValueTypeMarker>::borrow),
9813 encoder,
9814 offset + cur_offset,
9815 depth,
9816 )?;
9817
9818 _prev_end_offset = cur_offset + envelope_size;
9819 if 6 > max_ordinal {
9820 return Ok(());
9821 }
9822
9823 let cur_offset: usize = (6 - 1) * envelope_size;
9826
9827 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9829
9830 fidl::encoding::encode_in_envelope_optional::<PlayerApplicationSettings, D>(
9835 self.application_settings
9836 .as_ref()
9837 .map(<PlayerApplicationSettings as fidl::encoding::ValueTypeMarker>::borrow),
9838 encoder,
9839 offset + cur_offset,
9840 depth,
9841 )?;
9842
9843 _prev_end_offset = cur_offset + envelope_size;
9844 if 7 > max_ordinal {
9845 return Ok(());
9846 }
9847
9848 let cur_offset: usize = (7 - 1) * envelope_size;
9851
9852 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9854
9855 fidl::encoding::encode_in_envelope_optional::<u16, D>(
9860 self.player_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9861 encoder,
9862 offset + cur_offset,
9863 depth,
9864 )?;
9865
9866 _prev_end_offset = cur_offset + envelope_size;
9867 if 8 > max_ordinal {
9868 return Ok(());
9869 }
9870
9871 let cur_offset: usize = (8 - 1) * envelope_size;
9874
9875 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9877
9878 fidl::encoding::encode_in_envelope_optional::<u8, D>(
9883 self.volume.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
9884 encoder,
9885 offset + cur_offset,
9886 depth,
9887 )?;
9888
9889 _prev_end_offset = cur_offset + envelope_size;
9890 if 9 > max_ordinal {
9891 return Ok(());
9892 }
9893
9894 let cur_offset: usize = (9 - 1) * envelope_size;
9897
9898 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9900
9901 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9906 self.device_connected
9907 .as_ref()
9908 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9909 encoder,
9910 offset + cur_offset,
9911 depth,
9912 )?;
9913
9914 _prev_end_offset = cur_offset + envelope_size;
9915 if 10 > max_ordinal {
9916 return Ok(());
9917 }
9918
9919 let cur_offset: usize = (10 - 1) * envelope_size;
9922
9923 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9925
9926 fidl::encoding::encode_in_envelope_optional::<bool, D>(
9931 self.available_players_changed
9932 .as_ref()
9933 .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
9934 encoder,
9935 offset + cur_offset,
9936 depth,
9937 )?;
9938
9939 _prev_end_offset = cur_offset + envelope_size;
9940 if 11 > max_ordinal {
9941 return Ok(());
9942 }
9943
9944 let cur_offset: usize = (11 - 1) * envelope_size;
9947
9948 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9950
9951 fidl::encoding::encode_in_envelope_optional::<u16, D>(
9956 self.addressed_player
9957 .as_ref()
9958 .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
9959 encoder,
9960 offset + cur_offset,
9961 depth,
9962 )?;
9963
9964 _prev_end_offset = cur_offset + envelope_size;
9965
9966 Ok(())
9967 }
9968 }
9969
9970 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Notification {
9971 #[inline(always)]
9972 fn new_empty() -> Self {
9973 Self::default()
9974 }
9975
9976 unsafe fn decode(
9977 &mut self,
9978 decoder: &mut fidl::encoding::Decoder<'_, D>,
9979 offset: usize,
9980 mut depth: fidl::encoding::Depth,
9981 ) -> fidl::Result<()> {
9982 decoder.debug_check_bounds::<Self>(offset);
9983 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9984 None => return Err(fidl::Error::NotNullable),
9985 Some(len) => len,
9986 };
9987 if len == 0 {
9989 return Ok(());
9990 };
9991 depth.increment()?;
9992 let envelope_size = 8;
9993 let bytes_len = len * envelope_size;
9994 let offset = decoder.out_of_line_offset(bytes_len)?;
9995 let mut _next_ordinal_to_read = 0;
9997 let mut next_offset = offset;
9998 let end_offset = offset + bytes_len;
9999 _next_ordinal_to_read += 1;
10000 if next_offset >= end_offset {
10001 return Ok(());
10002 }
10003
10004 while _next_ordinal_to_read < 1 {
10006 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10007 _next_ordinal_to_read += 1;
10008 next_offset += envelope_size;
10009 }
10010
10011 let next_out_of_line = decoder.next_out_of_line();
10012 let handles_before = decoder.remaining_handles();
10013 if let Some((inlined, num_bytes, num_handles)) =
10014 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10015 {
10016 let member_inline_size =
10017 <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10018 if inlined != (member_inline_size <= 4) {
10019 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10020 }
10021 let inner_offset;
10022 let mut inner_depth = depth.clone();
10023 if inlined {
10024 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10025 inner_offset = next_offset;
10026 } else {
10027 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10028 inner_depth.increment()?;
10029 }
10030 let val_ref =
10031 self.status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
10032 fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10033 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10034 {
10035 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10036 }
10037 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10038 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10039 }
10040 }
10041
10042 next_offset += envelope_size;
10043 _next_ordinal_to_read += 1;
10044 if next_offset >= end_offset {
10045 return Ok(());
10046 }
10047
10048 while _next_ordinal_to_read < 2 {
10050 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10051 _next_ordinal_to_read += 1;
10052 next_offset += envelope_size;
10053 }
10054
10055 let next_out_of_line = decoder.next_out_of_line();
10056 let handles_before = decoder.remaining_handles();
10057 if let Some((inlined, num_bytes, num_handles)) =
10058 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10059 {
10060 let member_inline_size =
10061 <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10062 if inlined != (member_inline_size <= 4) {
10063 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10064 }
10065 let inner_offset;
10066 let mut inner_depth = depth.clone();
10067 if inlined {
10068 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10069 inner_offset = next_offset;
10070 } else {
10071 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10072 inner_depth.increment()?;
10073 }
10074 let val_ref = self.track_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
10075 fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10076 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10077 {
10078 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10079 }
10080 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10081 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10082 }
10083 }
10084
10085 next_offset += envelope_size;
10086 _next_ordinal_to_read += 1;
10087 if next_offset >= end_offset {
10088 return Ok(());
10089 }
10090
10091 while _next_ordinal_to_read < 3 {
10093 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10094 _next_ordinal_to_read += 1;
10095 next_offset += envelope_size;
10096 }
10097
10098 let next_out_of_line = decoder.next_out_of_line();
10099 let handles_before = decoder.remaining_handles();
10100 if let Some((inlined, num_bytes, num_handles)) =
10101 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10102 {
10103 let member_inline_size =
10104 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10105 if inlined != (member_inline_size <= 4) {
10106 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10107 }
10108 let inner_offset;
10109 let mut inner_depth = depth.clone();
10110 if inlined {
10111 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10112 inner_offset = next_offset;
10113 } else {
10114 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10115 inner_depth.increment()?;
10116 }
10117 let val_ref = self.pos.get_or_insert_with(|| fidl::new_empty!(u32, D));
10118 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10119 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10120 {
10121 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10122 }
10123 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10124 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10125 }
10126 }
10127
10128 next_offset += envelope_size;
10129 _next_ordinal_to_read += 1;
10130 if next_offset >= end_offset {
10131 return Ok(());
10132 }
10133
10134 while _next_ordinal_to_read < 4 {
10136 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10137 _next_ordinal_to_read += 1;
10138 next_offset += envelope_size;
10139 }
10140
10141 let next_out_of_line = decoder.next_out_of_line();
10142 let handles_before = decoder.remaining_handles();
10143 if let Some((inlined, num_bytes, num_handles)) =
10144 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10145 {
10146 let member_inline_size =
10147 <BatteryStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10148 if inlined != (member_inline_size <= 4) {
10149 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10150 }
10151 let inner_offset;
10152 let mut inner_depth = depth.clone();
10153 if inlined {
10154 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10155 inner_offset = next_offset;
10156 } else {
10157 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10158 inner_depth.increment()?;
10159 }
10160 let val_ref =
10161 self.battery_status.get_or_insert_with(|| fidl::new_empty!(BatteryStatus, D));
10162 fidl::decode!(BatteryStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10163 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10164 {
10165 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10166 }
10167 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10168 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10169 }
10170 }
10171
10172 next_offset += envelope_size;
10173 _next_ordinal_to_read += 1;
10174 if next_offset >= end_offset {
10175 return Ok(());
10176 }
10177
10178 while _next_ordinal_to_read < 5 {
10180 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10181 _next_ordinal_to_read += 1;
10182 next_offset += envelope_size;
10183 }
10184
10185 let next_out_of_line = decoder.next_out_of_line();
10186 let handles_before = decoder.remaining_handles();
10187 if let Some((inlined, num_bytes, num_handles)) =
10188 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10189 {
10190 let member_inline_size =
10191 <SystemStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10192 if inlined != (member_inline_size <= 4) {
10193 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10194 }
10195 let inner_offset;
10196 let mut inner_depth = depth.clone();
10197 if inlined {
10198 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10199 inner_offset = next_offset;
10200 } else {
10201 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10202 inner_depth.increment()?;
10203 }
10204 let val_ref =
10205 self.system_status.get_or_insert_with(|| fidl::new_empty!(SystemStatus, D));
10206 fidl::decode!(SystemStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10207 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10208 {
10209 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10210 }
10211 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10212 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10213 }
10214 }
10215
10216 next_offset += envelope_size;
10217 _next_ordinal_to_read += 1;
10218 if next_offset >= end_offset {
10219 return Ok(());
10220 }
10221
10222 while _next_ordinal_to_read < 6 {
10224 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10225 _next_ordinal_to_read += 1;
10226 next_offset += envelope_size;
10227 }
10228
10229 let next_out_of_line = decoder.next_out_of_line();
10230 let handles_before = decoder.remaining_handles();
10231 if let Some((inlined, num_bytes, num_handles)) =
10232 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10233 {
10234 let member_inline_size =
10235 <PlayerApplicationSettings as fidl::encoding::TypeMarker>::inline_size(
10236 decoder.context,
10237 );
10238 if inlined != (member_inline_size <= 4) {
10239 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10240 }
10241 let inner_offset;
10242 let mut inner_depth = depth.clone();
10243 if inlined {
10244 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10245 inner_offset = next_offset;
10246 } else {
10247 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10248 inner_depth.increment()?;
10249 }
10250 let val_ref = self
10251 .application_settings
10252 .get_or_insert_with(|| fidl::new_empty!(PlayerApplicationSettings, D));
10253 fidl::decode!(
10254 PlayerApplicationSettings,
10255 D,
10256 val_ref,
10257 decoder,
10258 inner_offset,
10259 inner_depth
10260 )?;
10261 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10262 {
10263 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10264 }
10265 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10266 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10267 }
10268 }
10269
10270 next_offset += envelope_size;
10271 _next_ordinal_to_read += 1;
10272 if next_offset >= end_offset {
10273 return Ok(());
10274 }
10275
10276 while _next_ordinal_to_read < 7 {
10278 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10279 _next_ordinal_to_read += 1;
10280 next_offset += envelope_size;
10281 }
10282
10283 let next_out_of_line = decoder.next_out_of_line();
10284 let handles_before = decoder.remaining_handles();
10285 if let Some((inlined, num_bytes, num_handles)) =
10286 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10287 {
10288 let member_inline_size =
10289 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10290 if inlined != (member_inline_size <= 4) {
10291 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10292 }
10293 let inner_offset;
10294 let mut inner_depth = depth.clone();
10295 if inlined {
10296 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10297 inner_offset = next_offset;
10298 } else {
10299 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10300 inner_depth.increment()?;
10301 }
10302 let val_ref = self.player_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
10303 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10304 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10305 {
10306 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10307 }
10308 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10309 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10310 }
10311 }
10312
10313 next_offset += envelope_size;
10314 _next_ordinal_to_read += 1;
10315 if next_offset >= end_offset {
10316 return Ok(());
10317 }
10318
10319 while _next_ordinal_to_read < 8 {
10321 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10322 _next_ordinal_to_read += 1;
10323 next_offset += envelope_size;
10324 }
10325
10326 let next_out_of_line = decoder.next_out_of_line();
10327 let handles_before = decoder.remaining_handles();
10328 if let Some((inlined, num_bytes, num_handles)) =
10329 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10330 {
10331 let member_inline_size =
10332 <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10333 if inlined != (member_inline_size <= 4) {
10334 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10335 }
10336 let inner_offset;
10337 let mut inner_depth = depth.clone();
10338 if inlined {
10339 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10340 inner_offset = next_offset;
10341 } else {
10342 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10343 inner_depth.increment()?;
10344 }
10345 let val_ref = self.volume.get_or_insert_with(|| fidl::new_empty!(u8, D));
10346 fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
10347 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10348 {
10349 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10350 }
10351 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10352 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10353 }
10354 }
10355
10356 next_offset += envelope_size;
10357 _next_ordinal_to_read += 1;
10358 if next_offset >= end_offset {
10359 return Ok(());
10360 }
10361
10362 while _next_ordinal_to_read < 9 {
10364 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10365 _next_ordinal_to_read += 1;
10366 next_offset += envelope_size;
10367 }
10368
10369 let next_out_of_line = decoder.next_out_of_line();
10370 let handles_before = decoder.remaining_handles();
10371 if let Some((inlined, num_bytes, num_handles)) =
10372 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10373 {
10374 let member_inline_size =
10375 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10376 if inlined != (member_inline_size <= 4) {
10377 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10378 }
10379 let inner_offset;
10380 let mut inner_depth = depth.clone();
10381 if inlined {
10382 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10383 inner_offset = next_offset;
10384 } else {
10385 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10386 inner_depth.increment()?;
10387 }
10388 let val_ref =
10389 self.device_connected.get_or_insert_with(|| fidl::new_empty!(bool, D));
10390 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10391 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10392 {
10393 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10394 }
10395 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10396 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10397 }
10398 }
10399
10400 next_offset += envelope_size;
10401 _next_ordinal_to_read += 1;
10402 if next_offset >= end_offset {
10403 return Ok(());
10404 }
10405
10406 while _next_ordinal_to_read < 10 {
10408 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10409 _next_ordinal_to_read += 1;
10410 next_offset += envelope_size;
10411 }
10412
10413 let next_out_of_line = decoder.next_out_of_line();
10414 let handles_before = decoder.remaining_handles();
10415 if let Some((inlined, num_bytes, num_handles)) =
10416 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10417 {
10418 let member_inline_size =
10419 <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10420 if inlined != (member_inline_size <= 4) {
10421 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10422 }
10423 let inner_offset;
10424 let mut inner_depth = depth.clone();
10425 if inlined {
10426 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10427 inner_offset = next_offset;
10428 } else {
10429 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10430 inner_depth.increment()?;
10431 }
10432 let val_ref =
10433 self.available_players_changed.get_or_insert_with(|| fidl::new_empty!(bool, D));
10434 fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10435 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10436 {
10437 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10438 }
10439 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10440 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10441 }
10442 }
10443
10444 next_offset += envelope_size;
10445 _next_ordinal_to_read += 1;
10446 if next_offset >= end_offset {
10447 return Ok(());
10448 }
10449
10450 while _next_ordinal_to_read < 11 {
10452 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10453 _next_ordinal_to_read += 1;
10454 next_offset += envelope_size;
10455 }
10456
10457 let next_out_of_line = decoder.next_out_of_line();
10458 let handles_before = decoder.remaining_handles();
10459 if let Some((inlined, num_bytes, num_handles)) =
10460 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10461 {
10462 let member_inline_size =
10463 <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10464 if inlined != (member_inline_size <= 4) {
10465 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10466 }
10467 let inner_offset;
10468 let mut inner_depth = depth.clone();
10469 if inlined {
10470 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10471 inner_offset = next_offset;
10472 } else {
10473 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10474 inner_depth.increment()?;
10475 }
10476 let val_ref = self.addressed_player.get_or_insert_with(|| fidl::new_empty!(u16, D));
10477 fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10478 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10479 {
10480 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10481 }
10482 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10483 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10484 }
10485 }
10486
10487 next_offset += envelope_size;
10488
10489 while next_offset < end_offset {
10491 _next_ordinal_to_read += 1;
10492 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10493 next_offset += envelope_size;
10494 }
10495
10496 Ok(())
10497 }
10498 }
10499
10500 impl PlayStatus {
10501 #[inline(always)]
10502 fn max_ordinal_present(&self) -> u64 {
10503 if let Some(_) = self.playback_status {
10504 return 3;
10505 }
10506 if let Some(_) = self.song_position {
10507 return 2;
10508 }
10509 if let Some(_) = self.song_length {
10510 return 1;
10511 }
10512 0
10513 }
10514 }
10515
10516 impl fidl::encoding::ValueTypeMarker for PlayStatus {
10517 type Borrowed<'a> = &'a Self;
10518 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10519 value
10520 }
10521 }
10522
10523 unsafe impl fidl::encoding::TypeMarker for PlayStatus {
10524 type Owned = Self;
10525
10526 #[inline(always)]
10527 fn inline_align(_context: fidl::encoding::Context) -> usize {
10528 8
10529 }
10530
10531 #[inline(always)]
10532 fn inline_size(_context: fidl::encoding::Context) -> usize {
10533 16
10534 }
10535 }
10536
10537 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PlayStatus, D>
10538 for &PlayStatus
10539 {
10540 unsafe fn encode(
10541 self,
10542 encoder: &mut fidl::encoding::Encoder<'_, D>,
10543 offset: usize,
10544 mut depth: fidl::encoding::Depth,
10545 ) -> fidl::Result<()> {
10546 encoder.debug_check_bounds::<PlayStatus>(offset);
10547 let max_ordinal: u64 = self.max_ordinal_present();
10549 encoder.write_num(max_ordinal, offset);
10550 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10551 if max_ordinal == 0 {
10553 return Ok(());
10554 }
10555 depth.increment()?;
10556 let envelope_size = 8;
10557 let bytes_len = max_ordinal as usize * envelope_size;
10558 #[allow(unused_variables)]
10559 let offset = encoder.out_of_line_offset(bytes_len);
10560 let mut _prev_end_offset: usize = 0;
10561 if 1 > max_ordinal {
10562 return Ok(());
10563 }
10564
10565 let cur_offset: usize = (1 - 1) * envelope_size;
10568
10569 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10571
10572 fidl::encoding::encode_in_envelope_optional::<u32, D>(
10577 self.song_length.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
10578 encoder,
10579 offset + cur_offset,
10580 depth,
10581 )?;
10582
10583 _prev_end_offset = cur_offset + envelope_size;
10584 if 2 > max_ordinal {
10585 return Ok(());
10586 }
10587
10588 let cur_offset: usize = (2 - 1) * envelope_size;
10591
10592 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10594
10595 fidl::encoding::encode_in_envelope_optional::<u32, D>(
10600 self.song_position.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
10601 encoder,
10602 offset + cur_offset,
10603 depth,
10604 )?;
10605
10606 _prev_end_offset = cur_offset + envelope_size;
10607 if 3 > max_ordinal {
10608 return Ok(());
10609 }
10610
10611 let cur_offset: usize = (3 - 1) * envelope_size;
10614
10615 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10617
10618 fidl::encoding::encode_in_envelope_optional::<PlaybackStatus, D>(
10623 self.playback_status
10624 .as_ref()
10625 .map(<PlaybackStatus as fidl::encoding::ValueTypeMarker>::borrow),
10626 encoder,
10627 offset + cur_offset,
10628 depth,
10629 )?;
10630
10631 _prev_end_offset = cur_offset + envelope_size;
10632
10633 Ok(())
10634 }
10635 }
10636
10637 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlayStatus {
10638 #[inline(always)]
10639 fn new_empty() -> Self {
10640 Self::default()
10641 }
10642
10643 unsafe fn decode(
10644 &mut self,
10645 decoder: &mut fidl::encoding::Decoder<'_, D>,
10646 offset: usize,
10647 mut depth: fidl::encoding::Depth,
10648 ) -> fidl::Result<()> {
10649 decoder.debug_check_bounds::<Self>(offset);
10650 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10651 None => return Err(fidl::Error::NotNullable),
10652 Some(len) => len,
10653 };
10654 if len == 0 {
10656 return Ok(());
10657 };
10658 depth.increment()?;
10659 let envelope_size = 8;
10660 let bytes_len = len * envelope_size;
10661 let offset = decoder.out_of_line_offset(bytes_len)?;
10662 let mut _next_ordinal_to_read = 0;
10664 let mut next_offset = offset;
10665 let end_offset = offset + bytes_len;
10666 _next_ordinal_to_read += 1;
10667 if next_offset >= end_offset {
10668 return Ok(());
10669 }
10670
10671 while _next_ordinal_to_read < 1 {
10673 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10674 _next_ordinal_to_read += 1;
10675 next_offset += envelope_size;
10676 }
10677
10678 let next_out_of_line = decoder.next_out_of_line();
10679 let handles_before = decoder.remaining_handles();
10680 if let Some((inlined, num_bytes, num_handles)) =
10681 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10682 {
10683 let member_inline_size =
10684 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10685 if inlined != (member_inline_size <= 4) {
10686 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10687 }
10688 let inner_offset;
10689 let mut inner_depth = depth.clone();
10690 if inlined {
10691 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10692 inner_offset = next_offset;
10693 } else {
10694 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10695 inner_depth.increment()?;
10696 }
10697 let val_ref = self.song_length.get_or_insert_with(|| fidl::new_empty!(u32, D));
10698 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10699 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10700 {
10701 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10702 }
10703 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10704 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10705 }
10706 }
10707
10708 next_offset += envelope_size;
10709 _next_ordinal_to_read += 1;
10710 if next_offset >= end_offset {
10711 return Ok(());
10712 }
10713
10714 while _next_ordinal_to_read < 2 {
10716 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10717 _next_ordinal_to_read += 1;
10718 next_offset += envelope_size;
10719 }
10720
10721 let next_out_of_line = decoder.next_out_of_line();
10722 let handles_before = decoder.remaining_handles();
10723 if let Some((inlined, num_bytes, num_handles)) =
10724 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10725 {
10726 let member_inline_size =
10727 <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10728 if inlined != (member_inline_size <= 4) {
10729 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10730 }
10731 let inner_offset;
10732 let mut inner_depth = depth.clone();
10733 if inlined {
10734 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10735 inner_offset = next_offset;
10736 } else {
10737 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10738 inner_depth.increment()?;
10739 }
10740 let val_ref = self.song_position.get_or_insert_with(|| fidl::new_empty!(u32, D));
10741 fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
10742 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10743 {
10744 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10745 }
10746 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10747 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10748 }
10749 }
10750
10751 next_offset += envelope_size;
10752 _next_ordinal_to_read += 1;
10753 if next_offset >= end_offset {
10754 return Ok(());
10755 }
10756
10757 while _next_ordinal_to_read < 3 {
10759 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10760 _next_ordinal_to_read += 1;
10761 next_offset += envelope_size;
10762 }
10763
10764 let next_out_of_line = decoder.next_out_of_line();
10765 let handles_before = decoder.remaining_handles();
10766 if let Some((inlined, num_bytes, num_handles)) =
10767 fidl::encoding::decode_envelope_header(decoder, next_offset)?
10768 {
10769 let member_inline_size =
10770 <PlaybackStatus as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10771 if inlined != (member_inline_size <= 4) {
10772 return Err(fidl::Error::InvalidInlineBitInEnvelope);
10773 }
10774 let inner_offset;
10775 let mut inner_depth = depth.clone();
10776 if inlined {
10777 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10778 inner_offset = next_offset;
10779 } else {
10780 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10781 inner_depth.increment()?;
10782 }
10783 let val_ref =
10784 self.playback_status.get_or_insert_with(|| fidl::new_empty!(PlaybackStatus, D));
10785 fidl::decode!(PlaybackStatus, D, val_ref, decoder, inner_offset, inner_depth)?;
10786 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10787 {
10788 return Err(fidl::Error::InvalidNumBytesInEnvelope);
10789 }
10790 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10791 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10792 }
10793 }
10794
10795 next_offset += envelope_size;
10796
10797 while next_offset < end_offset {
10799 _next_ordinal_to_read += 1;
10800 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10801 next_offset += envelope_size;
10802 }
10803
10804 Ok(())
10805 }
10806 }
10807
10808 impl PlayerApplicationSettings {
10809 #[inline(always)]
10810 fn max_ordinal_present(&self) -> u64 {
10811 if let Some(_) = self.custom_settings {
10812 return 5;
10813 }
10814 if let Some(_) = self.scan_mode {
10815 return 4;
10816 }
10817 if let Some(_) = self.shuffle_mode {
10818 return 3;
10819 }
10820 if let Some(_) = self.repeat_status_mode {
10821 return 2;
10822 }
10823 if let Some(_) = self.equalizer {
10824 return 1;
10825 }
10826 0
10827 }
10828 }
10829
10830 impl fidl::encoding::ValueTypeMarker for PlayerApplicationSettings {
10831 type Borrowed<'a> = &'a Self;
10832 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10833 value
10834 }
10835 }
10836
10837 unsafe impl fidl::encoding::TypeMarker for PlayerApplicationSettings {
10838 type Owned = Self;
10839
10840 #[inline(always)]
10841 fn inline_align(_context: fidl::encoding::Context) -> usize {
10842 8
10843 }
10844
10845 #[inline(always)]
10846 fn inline_size(_context: fidl::encoding::Context) -> usize {
10847 16
10848 }
10849 }
10850
10851 unsafe impl<D: fidl::encoding::ResourceDialect>
10852 fidl::encoding::Encode<PlayerApplicationSettings, D> for &PlayerApplicationSettings
10853 {
10854 unsafe fn encode(
10855 self,
10856 encoder: &mut fidl::encoding::Encoder<'_, D>,
10857 offset: usize,
10858 mut depth: fidl::encoding::Depth,
10859 ) -> fidl::Result<()> {
10860 encoder.debug_check_bounds::<PlayerApplicationSettings>(offset);
10861 let max_ordinal: u64 = self.max_ordinal_present();
10863 encoder.write_num(max_ordinal, offset);
10864 encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10865 if max_ordinal == 0 {
10867 return Ok(());
10868 }
10869 depth.increment()?;
10870 let envelope_size = 8;
10871 let bytes_len = max_ordinal as usize * envelope_size;
10872 #[allow(unused_variables)]
10873 let offset = encoder.out_of_line_offset(bytes_len);
10874 let mut _prev_end_offset: usize = 0;
10875 if 1 > max_ordinal {
10876 return Ok(());
10877 }
10878
10879 let cur_offset: usize = (1 - 1) * envelope_size;
10882
10883 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10885
10886 fidl::encoding::encode_in_envelope_optional::<Equalizer, D>(
10891 self.equalizer.as_ref().map(<Equalizer as fidl::encoding::ValueTypeMarker>::borrow),
10892 encoder,
10893 offset + cur_offset,
10894 depth,
10895 )?;
10896
10897 _prev_end_offset = cur_offset + envelope_size;
10898 if 2 > max_ordinal {
10899 return Ok(());
10900 }
10901
10902 let cur_offset: usize = (2 - 1) * envelope_size;
10905
10906 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10908
10909 fidl::encoding::encode_in_envelope_optional::<RepeatStatusMode, D>(
10914 self.repeat_status_mode
10915 .as_ref()
10916 .map(<RepeatStatusMode as fidl::encoding::ValueTypeMarker>::borrow),
10917 encoder,
10918 offset + cur_offset,
10919 depth,
10920 )?;
10921
10922 _prev_end_offset = cur_offset + envelope_size;
10923 if 3 > max_ordinal {
10924 return Ok(());
10925 }
10926
10927 let cur_offset: usize = (3 - 1) * envelope_size;
10930
10931 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10933
10934 fidl::encoding::encode_in_envelope_optional::<ShuffleMode, D>(
10939 self.shuffle_mode
10940 .as_ref()
10941 .map(<ShuffleMode as fidl::encoding::ValueTypeMarker>::borrow),
10942 encoder,
10943 offset + cur_offset,
10944 depth,
10945 )?;
10946
10947 _prev_end_offset = cur_offset + envelope_size;
10948 if 4 > max_ordinal {
10949 return Ok(());
10950 }
10951
10952 let cur_offset: usize = (4 - 1) * envelope_size;
10955
10956 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10958
10959 fidl::encoding::encode_in_envelope_optional::<ScanMode, D>(
10964 self.scan_mode.as_ref().map(<ScanMode as fidl::encoding::ValueTypeMarker>::borrow),
10965 encoder,
10966 offset + cur_offset,
10967 depth,
10968 )?;
10969
10970 _prev_end_offset = cur_offset + envelope_size;
10971 if 5 > max_ordinal {
10972 return Ok(());
10973 }
10974
10975 let cur_offset: usize = (5 - 1) * envelope_size;
10978
10979 encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10981
10982 fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D>(
10987 self.custom_settings.as_ref().map(<fidl::encoding::Vector<CustomPlayerApplicationSetting, 127> as fidl::encoding::ValueTypeMarker>::borrow),
10988 encoder, offset + cur_offset, depth
10989 )?;
10990
10991 _prev_end_offset = cur_offset + envelope_size;
10992
10993 Ok(())
10994 }
10995 }
10996
10997 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10998 for PlayerApplicationSettings
10999 {
11000 #[inline(always)]
11001 fn new_empty() -> Self {
11002 Self::default()
11003 }
11004
11005 unsafe fn decode(
11006 &mut self,
11007 decoder: &mut fidl::encoding::Decoder<'_, D>,
11008 offset: usize,
11009 mut depth: fidl::encoding::Depth,
11010 ) -> fidl::Result<()> {
11011 decoder.debug_check_bounds::<Self>(offset);
11012 let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11013 None => return Err(fidl::Error::NotNullable),
11014 Some(len) => len,
11015 };
11016 if len == 0 {
11018 return Ok(());
11019 };
11020 depth.increment()?;
11021 let envelope_size = 8;
11022 let bytes_len = len * envelope_size;
11023 let offset = decoder.out_of_line_offset(bytes_len)?;
11024 let mut _next_ordinal_to_read = 0;
11026 let mut next_offset = offset;
11027 let end_offset = offset + bytes_len;
11028 _next_ordinal_to_read += 1;
11029 if next_offset >= end_offset {
11030 return Ok(());
11031 }
11032
11033 while _next_ordinal_to_read < 1 {
11035 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11036 _next_ordinal_to_read += 1;
11037 next_offset += envelope_size;
11038 }
11039
11040 let next_out_of_line = decoder.next_out_of_line();
11041 let handles_before = decoder.remaining_handles();
11042 if let Some((inlined, num_bytes, num_handles)) =
11043 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11044 {
11045 let member_inline_size =
11046 <Equalizer as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11047 if inlined != (member_inline_size <= 4) {
11048 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11049 }
11050 let inner_offset;
11051 let mut inner_depth = depth.clone();
11052 if inlined {
11053 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11054 inner_offset = next_offset;
11055 } else {
11056 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11057 inner_depth.increment()?;
11058 }
11059 let val_ref = self.equalizer.get_or_insert_with(|| fidl::new_empty!(Equalizer, D));
11060 fidl::decode!(Equalizer, D, val_ref, decoder, inner_offset, inner_depth)?;
11061 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11062 {
11063 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11064 }
11065 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11066 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11067 }
11068 }
11069
11070 next_offset += envelope_size;
11071 _next_ordinal_to_read += 1;
11072 if next_offset >= end_offset {
11073 return Ok(());
11074 }
11075
11076 while _next_ordinal_to_read < 2 {
11078 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11079 _next_ordinal_to_read += 1;
11080 next_offset += envelope_size;
11081 }
11082
11083 let next_out_of_line = decoder.next_out_of_line();
11084 let handles_before = decoder.remaining_handles();
11085 if let Some((inlined, num_bytes, num_handles)) =
11086 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11087 {
11088 let member_inline_size =
11089 <RepeatStatusMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11090 if inlined != (member_inline_size <= 4) {
11091 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11092 }
11093 let inner_offset;
11094 let mut inner_depth = depth.clone();
11095 if inlined {
11096 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11097 inner_offset = next_offset;
11098 } else {
11099 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11100 inner_depth.increment()?;
11101 }
11102 let val_ref = self
11103 .repeat_status_mode
11104 .get_or_insert_with(|| fidl::new_empty!(RepeatStatusMode, D));
11105 fidl::decode!(RepeatStatusMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11106 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11107 {
11108 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11109 }
11110 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11111 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11112 }
11113 }
11114
11115 next_offset += envelope_size;
11116 _next_ordinal_to_read += 1;
11117 if next_offset >= end_offset {
11118 return Ok(());
11119 }
11120
11121 while _next_ordinal_to_read < 3 {
11123 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11124 _next_ordinal_to_read += 1;
11125 next_offset += envelope_size;
11126 }
11127
11128 let next_out_of_line = decoder.next_out_of_line();
11129 let handles_before = decoder.remaining_handles();
11130 if let Some((inlined, num_bytes, num_handles)) =
11131 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11132 {
11133 let member_inline_size =
11134 <ShuffleMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11135 if inlined != (member_inline_size <= 4) {
11136 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11137 }
11138 let inner_offset;
11139 let mut inner_depth = depth.clone();
11140 if inlined {
11141 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11142 inner_offset = next_offset;
11143 } else {
11144 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11145 inner_depth.increment()?;
11146 }
11147 let val_ref =
11148 self.shuffle_mode.get_or_insert_with(|| fidl::new_empty!(ShuffleMode, D));
11149 fidl::decode!(ShuffleMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11150 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11151 {
11152 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11153 }
11154 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11155 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11156 }
11157 }
11158
11159 next_offset += envelope_size;
11160 _next_ordinal_to_read += 1;
11161 if next_offset >= end_offset {
11162 return Ok(());
11163 }
11164
11165 while _next_ordinal_to_read < 4 {
11167 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11168 _next_ordinal_to_read += 1;
11169 next_offset += envelope_size;
11170 }
11171
11172 let next_out_of_line = decoder.next_out_of_line();
11173 let handles_before = decoder.remaining_handles();
11174 if let Some((inlined, num_bytes, num_handles)) =
11175 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11176 {
11177 let member_inline_size =
11178 <ScanMode as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11179 if inlined != (member_inline_size <= 4) {
11180 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11181 }
11182 let inner_offset;
11183 let mut inner_depth = depth.clone();
11184 if inlined {
11185 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11186 inner_offset = next_offset;
11187 } else {
11188 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11189 inner_depth.increment()?;
11190 }
11191 let val_ref = self.scan_mode.get_or_insert_with(|| fidl::new_empty!(ScanMode, D));
11192 fidl::decode!(ScanMode, D, val_ref, decoder, inner_offset, inner_depth)?;
11193 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11194 {
11195 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11196 }
11197 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11198 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11199 }
11200 }
11201
11202 next_offset += envelope_size;
11203 _next_ordinal_to_read += 1;
11204 if next_offset >= end_offset {
11205 return Ok(());
11206 }
11207
11208 while _next_ordinal_to_read < 5 {
11210 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11211 _next_ordinal_to_read += 1;
11212 next_offset += envelope_size;
11213 }
11214
11215 let next_out_of_line = decoder.next_out_of_line();
11216 let handles_before = decoder.remaining_handles();
11217 if let Some((inlined, num_bytes, num_handles)) =
11218 fidl::encoding::decode_envelope_header(decoder, next_offset)?
11219 {
11220 let member_inline_size = <fidl::encoding::Vector<
11221 CustomPlayerApplicationSetting,
11222 127,
11223 > as fidl::encoding::TypeMarker>::inline_size(
11224 decoder.context
11225 );
11226 if inlined != (member_inline_size <= 4) {
11227 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11228 }
11229 let inner_offset;
11230 let mut inner_depth = depth.clone();
11231 if inlined {
11232 decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11233 inner_offset = next_offset;
11234 } else {
11235 inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11236 inner_depth.increment()?;
11237 }
11238 let val_ref =
11239 self.custom_settings.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D));
11240 fidl::decode!(fidl::encoding::Vector<CustomPlayerApplicationSetting, 127>, D, val_ref, decoder, inner_offset, inner_depth)?;
11241 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11242 {
11243 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11244 }
11245 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11246 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11247 }
11248 }
11249
11250 next_offset += envelope_size;
11251
11252 while next_offset < end_offset {
11254 _next_ordinal_to_read += 1;
11255 fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11256 next_offset += envelope_size;
11257 }
11258
11259 Ok(())
11260 }
11261 }
11262
11263 impl fidl::encoding::ValueTypeMarker for AttributeRequestOption {
11264 type Borrowed<'a> = &'a Self;
11265 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11266 value
11267 }
11268 }
11269
11270 unsafe impl fidl::encoding::TypeMarker for AttributeRequestOption {
11271 type Owned = Self;
11272
11273 #[inline(always)]
11274 fn inline_align(_context: fidl::encoding::Context) -> usize {
11275 8
11276 }
11277
11278 #[inline(always)]
11279 fn inline_size(_context: fidl::encoding::Context) -> usize {
11280 16
11281 }
11282 }
11283
11284 unsafe impl<D: fidl::encoding::ResourceDialect>
11285 fidl::encoding::Encode<AttributeRequestOption, D> for &AttributeRequestOption
11286 {
11287 #[inline]
11288 unsafe fn encode(
11289 self,
11290 encoder: &mut fidl::encoding::Encoder<'_, D>,
11291 offset: usize,
11292 _depth: fidl::encoding::Depth,
11293 ) -> fidl::Result<()> {
11294 encoder.debug_check_bounds::<AttributeRequestOption>(offset);
11295 encoder.write_num::<u64>(self.ordinal(), offset);
11296 match self {
11297 AttributeRequestOption::GetAll(ref val) => {
11298 fidl::encoding::encode_in_envelope::<bool, D>(
11299 <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
11300 encoder, offset + 8, _depth
11301 )
11302 }
11303 AttributeRequestOption::AttributeList(ref val) => {
11304 fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<MediaAttributeId, 8>, D>(
11305 <fidl::encoding::Vector<MediaAttributeId, 8> as fidl::encoding::ValueTypeMarker>::borrow(val),
11306 encoder, offset + 8, _depth
11307 )
11308 }
11309 }
11310 }
11311 }
11312
11313 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
11314 for AttributeRequestOption
11315 {
11316 #[inline(always)]
11317 fn new_empty() -> Self {
11318 Self::GetAll(fidl::new_empty!(bool, D))
11319 }
11320
11321 #[inline]
11322 unsafe fn decode(
11323 &mut self,
11324 decoder: &mut fidl::encoding::Decoder<'_, D>,
11325 offset: usize,
11326 mut depth: fidl::encoding::Depth,
11327 ) -> fidl::Result<()> {
11328 decoder.debug_check_bounds::<Self>(offset);
11329 #[allow(unused_variables)]
11330 let next_out_of_line = decoder.next_out_of_line();
11331 let handles_before = decoder.remaining_handles();
11332 let (ordinal, inlined, num_bytes, num_handles) =
11333 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11334
11335 let member_inline_size = match ordinal {
11336 1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11337 2 => <fidl::encoding::Vector<MediaAttributeId, 8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11338 _ => return Err(fidl::Error::UnknownUnionTag),
11339 };
11340
11341 if inlined != (member_inline_size <= 4) {
11342 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11343 }
11344 let _inner_offset;
11345 if inlined {
11346 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11347 _inner_offset = offset + 8;
11348 } else {
11349 depth.increment()?;
11350 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11351 }
11352 match ordinal {
11353 1 => {
11354 #[allow(irrefutable_let_patterns)]
11355 if let AttributeRequestOption::GetAll(_) = self {
11356 } else {
11358 *self = AttributeRequestOption::GetAll(fidl::new_empty!(bool, D));
11360 }
11361 #[allow(irrefutable_let_patterns)]
11362 if let AttributeRequestOption::GetAll(ref mut val) = self {
11363 fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
11364 } else {
11365 unreachable!()
11366 }
11367 }
11368 2 => {
11369 #[allow(irrefutable_let_patterns)]
11370 if let AttributeRequestOption::AttributeList(_) = self {
11371 } else {
11373 *self = AttributeRequestOption::AttributeList(
11375 fidl::new_empty!(fidl::encoding::Vector<MediaAttributeId, 8>, D),
11376 );
11377 }
11378 #[allow(irrefutable_let_patterns)]
11379 if let AttributeRequestOption::AttributeList(ref mut val) = self {
11380 fidl::decode!(fidl::encoding::Vector<MediaAttributeId, 8>, D, val, decoder, _inner_offset, depth)?;
11381 } else {
11382 unreachable!()
11383 }
11384 }
11385 ordinal => panic!("unexpected ordinal {:?}", ordinal),
11386 }
11387 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11388 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11389 }
11390 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11391 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11392 }
11393 Ok(())
11394 }
11395 }
11396
11397 impl fidl::encoding::ValueTypeMarker for FileSystemItem {
11398 type Borrowed<'a> = &'a Self;
11399 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11400 value
11401 }
11402 }
11403
11404 unsafe impl fidl::encoding::TypeMarker for FileSystemItem {
11405 type Owned = Self;
11406
11407 #[inline(always)]
11408 fn inline_align(_context: fidl::encoding::Context) -> usize {
11409 8
11410 }
11411
11412 #[inline(always)]
11413 fn inline_size(_context: fidl::encoding::Context) -> usize {
11414 16
11415 }
11416 }
11417
11418 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FileSystemItem, D>
11419 for &FileSystemItem
11420 {
11421 #[inline]
11422 unsafe fn encode(
11423 self,
11424 encoder: &mut fidl::encoding::Encoder<'_, D>,
11425 offset: usize,
11426 _depth: fidl::encoding::Depth,
11427 ) -> fidl::Result<()> {
11428 encoder.debug_check_bounds::<FileSystemItem>(offset);
11429 encoder.write_num::<u64>(self.ordinal(), offset);
11430 match self {
11431 FileSystemItem::Folder(ref val) => {
11432 fidl::encoding::encode_in_envelope::<FolderItem, D>(
11433 <FolderItem as fidl::encoding::ValueTypeMarker>::borrow(val),
11434 encoder,
11435 offset + 8,
11436 _depth,
11437 )
11438 }
11439 FileSystemItem::MediaElement(ref val) => {
11440 fidl::encoding::encode_in_envelope::<MediaElementItem, D>(
11441 <MediaElementItem as fidl::encoding::ValueTypeMarker>::borrow(val),
11442 encoder,
11443 offset + 8,
11444 _depth,
11445 )
11446 }
11447 }
11448 }
11449 }
11450
11451 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FileSystemItem {
11452 #[inline(always)]
11453 fn new_empty() -> Self {
11454 Self::Folder(fidl::new_empty!(FolderItem, D))
11455 }
11456
11457 #[inline]
11458 unsafe fn decode(
11459 &mut self,
11460 decoder: &mut fidl::encoding::Decoder<'_, D>,
11461 offset: usize,
11462 mut depth: fidl::encoding::Depth,
11463 ) -> fidl::Result<()> {
11464 decoder.debug_check_bounds::<Self>(offset);
11465 #[allow(unused_variables)]
11466 let next_out_of_line = decoder.next_out_of_line();
11467 let handles_before = decoder.remaining_handles();
11468 let (ordinal, inlined, num_bytes, num_handles) =
11469 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11470
11471 let member_inline_size = match ordinal {
11472 1 => <FolderItem as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11473 2 => <MediaElementItem as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11474 _ => return Err(fidl::Error::UnknownUnionTag),
11475 };
11476
11477 if inlined != (member_inline_size <= 4) {
11478 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11479 }
11480 let _inner_offset;
11481 if inlined {
11482 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11483 _inner_offset = offset + 8;
11484 } else {
11485 depth.increment()?;
11486 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11487 }
11488 match ordinal {
11489 1 => {
11490 #[allow(irrefutable_let_patterns)]
11491 if let FileSystemItem::Folder(_) = self {
11492 } else {
11494 *self = FileSystemItem::Folder(fidl::new_empty!(FolderItem, D));
11496 }
11497 #[allow(irrefutable_let_patterns)]
11498 if let FileSystemItem::Folder(ref mut val) = self {
11499 fidl::decode!(FolderItem, D, val, decoder, _inner_offset, depth)?;
11500 } else {
11501 unreachable!()
11502 }
11503 }
11504 2 => {
11505 #[allow(irrefutable_let_patterns)]
11506 if let FileSystemItem::MediaElement(_) = self {
11507 } else {
11509 *self = FileSystemItem::MediaElement(fidl::new_empty!(MediaElementItem, D));
11511 }
11512 #[allow(irrefutable_let_patterns)]
11513 if let FileSystemItem::MediaElement(ref mut val) = self {
11514 fidl::decode!(MediaElementItem, D, val, decoder, _inner_offset, depth)?;
11515 } else {
11516 unreachable!()
11517 }
11518 }
11519 ordinal => panic!("unexpected ordinal {:?}", ordinal),
11520 }
11521 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11522 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11523 }
11524 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11525 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11526 }
11527 Ok(())
11528 }
11529 }
11530
11531 impl fidl::encoding::ValueTypeMarker for Path {
11532 type Borrowed<'a> = &'a Self;
11533 fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11534 value
11535 }
11536 }
11537
11538 unsafe impl fidl::encoding::TypeMarker for Path {
11539 type Owned = Self;
11540
11541 #[inline(always)]
11542 fn inline_align(_context: fidl::encoding::Context) -> usize {
11543 8
11544 }
11545
11546 #[inline(always)]
11547 fn inline_size(_context: fidl::encoding::Context) -> usize {
11548 16
11549 }
11550 }
11551
11552 unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Path, D> for &Path {
11553 #[inline]
11554 unsafe fn encode(
11555 self,
11556 encoder: &mut fidl::encoding::Encoder<'_, D>,
11557 offset: usize,
11558 _depth: fidl::encoding::Depth,
11559 ) -> fidl::Result<()> {
11560 encoder.debug_check_bounds::<Path>(offset);
11561 encoder.write_num::<u64>(self.ordinal(), offset);
11562 match self {
11563 Path::Parent(ref val) => fidl::encoding::encode_in_envelope::<Parent, D>(
11564 <Parent as fidl::encoding::ValueTypeMarker>::borrow(val),
11565 encoder,
11566 offset + 8,
11567 _depth,
11568 ),
11569 Path::ChildFolderUid(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
11570 <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
11571 encoder,
11572 offset + 8,
11573 _depth,
11574 ),
11575 Path::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
11576 }
11577 }
11578 }
11579
11580 impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Path {
11581 #[inline(always)]
11582 fn new_empty() -> Self {
11583 Self::__SourceBreaking { unknown_ordinal: 0 }
11584 }
11585
11586 #[inline]
11587 unsafe fn decode(
11588 &mut self,
11589 decoder: &mut fidl::encoding::Decoder<'_, D>,
11590 offset: usize,
11591 mut depth: fidl::encoding::Depth,
11592 ) -> fidl::Result<()> {
11593 decoder.debug_check_bounds::<Self>(offset);
11594 #[allow(unused_variables)]
11595 let next_out_of_line = decoder.next_out_of_line();
11596 let handles_before = decoder.remaining_handles();
11597 let (ordinal, inlined, num_bytes, num_handles) =
11598 fidl::encoding::decode_union_inline_portion(decoder, offset)?;
11599
11600 let member_inline_size = match ordinal {
11601 1 => <Parent as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11602 2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
11603 0 => return Err(fidl::Error::UnknownUnionTag),
11604 _ => num_bytes as usize,
11605 };
11606
11607 if inlined != (member_inline_size <= 4) {
11608 return Err(fidl::Error::InvalidInlineBitInEnvelope);
11609 }
11610 let _inner_offset;
11611 if inlined {
11612 decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
11613 _inner_offset = offset + 8;
11614 } else {
11615 depth.increment()?;
11616 _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11617 }
11618 match ordinal {
11619 1 => {
11620 #[allow(irrefutable_let_patterns)]
11621 if let Path::Parent(_) = self {
11622 } else {
11624 *self = Path::Parent(fidl::new_empty!(Parent, D));
11626 }
11627 #[allow(irrefutable_let_patterns)]
11628 if let Path::Parent(ref mut val) = self {
11629 fidl::decode!(Parent, D, val, decoder, _inner_offset, depth)?;
11630 } else {
11631 unreachable!()
11632 }
11633 }
11634 2 => {
11635 #[allow(irrefutable_let_patterns)]
11636 if let Path::ChildFolderUid(_) = self {
11637 } else {
11639 *self = Path::ChildFolderUid(fidl::new_empty!(u64, D));
11641 }
11642 #[allow(irrefutable_let_patterns)]
11643 if let Path::ChildFolderUid(ref mut val) = self {
11644 fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
11645 } else {
11646 unreachable!()
11647 }
11648 }
11649 #[allow(deprecated)]
11650 ordinal => {
11651 for _ in 0..num_handles {
11652 decoder.drop_next_handle()?;
11653 }
11654 *self = Path::__SourceBreaking { unknown_ordinal: ordinal };
11655 }
11656 }
11657 if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
11658 return Err(fidl::Error::InvalidNumBytesInEnvelope);
11659 }
11660 if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11661 return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11662 }
11663 Ok(())
11664 }
11665 }
11666}