pw_bluetooth_hci_data_emb/
hci_data.rs

1#![allow(dead_code, unused_imports, unused_variables, non_camel_case_types, unused_parens)]
2
3use emboss_runtime::prelude::*;
4pub use emboss_runtime::{BitFlag, Error, Flag, InfallibleRead, Int, MutStorage, Storage, TryRead, TryWrite, UInt, View, VirtualField};
5
6
7
8#[derive(Copy, Clone, Debug, Eq, PartialEq)]
9#[repr(u64)]
10pub enum AclDataPacketBoundaryFlag {
11    FIRST_NON_FLUSHABLE = 0,
12    CONTINUING_FRAGMENT = 1,
13    FIRST_FLUSHABLE = 2,
14
15}
16
17impl core::convert::From<AclDataPacketBoundaryFlag> for u8 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as u8 } }
18impl core::convert::From<AclDataPacketBoundaryFlag> for u16 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as u16 } }
19impl core::convert::From<AclDataPacketBoundaryFlag> for u32 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as u32 } }
20impl core::convert::From<AclDataPacketBoundaryFlag> for u64 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as u64 } }
21impl core::convert::From<AclDataPacketBoundaryFlag> for i8 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as i8 } }
22impl core::convert::From<AclDataPacketBoundaryFlag> for i16 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as i16 } }
23impl core::convert::From<AclDataPacketBoundaryFlag> for i32 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as i32 } }
24impl core::convert::From<AclDataPacketBoundaryFlag> for i64 { fn from(val: AclDataPacketBoundaryFlag) -> Self { val as i64 } }
25
26impl emboss_runtime::SafeCmp<AclDataPacketBoundaryFlag> for AclDataPacketBoundaryFlag {
27    fn safe_eq(&self, other: Self) -> bool { *self == other }
28    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
29}
30
31impl emboss_runtime::SafeCmp<u64> for AclDataPacketBoundaryFlag {
32    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
33    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
34}
35
36impl emboss_runtime::SafeCmp<i64> for AclDataPacketBoundaryFlag {
37    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
38    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
39}
40
41impl emboss_runtime::SafeCmp<i32> for AclDataPacketBoundaryFlag {
42    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
43    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
44}
45
46impl emboss_runtime::SafeCmp<u32> for AclDataPacketBoundaryFlag {
47    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
48    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
49}
50
51impl emboss_runtime::SafeCmp<AclDataPacketBoundaryFlag> for u64 {
52    fn safe_eq(&self, other: AclDataPacketBoundaryFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
53    fn safe_less(&self, other: AclDataPacketBoundaryFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
54}
55
56impl emboss_runtime::SafeCmp<AclDataPacketBoundaryFlag> for i64 {
57    fn safe_eq(&self, other: AclDataPacketBoundaryFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
58    fn safe_less(&self, other: AclDataPacketBoundaryFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
59}
60
61impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for AclDataPacketBoundaryFlag {
62    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
63        let v_raw: u64 = val.into();
64        match v_raw {
65            0 => Ok(AclDataPacketBoundaryFlag::FIRST_NON_FLUSHABLE),
66            1 => Ok(AclDataPacketBoundaryFlag::CONTINUING_FRAGMENT),
67            2 => Ok(AclDataPacketBoundaryFlag::FIRST_FLUSHABLE),
68
69            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
70        }
71    }
72}
73
74impl AclDataPacketBoundaryFlag {
75
76}
77#[derive(Copy, Clone, Debug, Eq, PartialEq)]
78#[repr(u64)]
79pub enum AclDataPacketBroadcastFlag {
80    POINT_TO_POINT = 0,
81    BROADCAST = 1,
82
83}
84
85impl core::convert::From<AclDataPacketBroadcastFlag> for u8 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as u8 } }
86impl core::convert::From<AclDataPacketBroadcastFlag> for u16 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as u16 } }
87impl core::convert::From<AclDataPacketBroadcastFlag> for u32 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as u32 } }
88impl core::convert::From<AclDataPacketBroadcastFlag> for u64 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as u64 } }
89impl core::convert::From<AclDataPacketBroadcastFlag> for i8 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as i8 } }
90impl core::convert::From<AclDataPacketBroadcastFlag> for i16 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as i16 } }
91impl core::convert::From<AclDataPacketBroadcastFlag> for i32 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as i32 } }
92impl core::convert::From<AclDataPacketBroadcastFlag> for i64 { fn from(val: AclDataPacketBroadcastFlag) -> Self { val as i64 } }
93
94impl emboss_runtime::SafeCmp<AclDataPacketBroadcastFlag> for AclDataPacketBroadcastFlag {
95    fn safe_eq(&self, other: Self) -> bool { *self == other }
96    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
97}
98
99impl emboss_runtime::SafeCmp<u64> for AclDataPacketBroadcastFlag {
100    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
101    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
102}
103
104impl emboss_runtime::SafeCmp<i64> for AclDataPacketBroadcastFlag {
105    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
106    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
107}
108
109impl emboss_runtime::SafeCmp<i32> for AclDataPacketBroadcastFlag {
110    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
111    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
112}
113
114impl emboss_runtime::SafeCmp<u32> for AclDataPacketBroadcastFlag {
115    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
116    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
117}
118
119impl emboss_runtime::SafeCmp<AclDataPacketBroadcastFlag> for u64 {
120    fn safe_eq(&self, other: AclDataPacketBroadcastFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
121    fn safe_less(&self, other: AclDataPacketBroadcastFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
122}
123
124impl emboss_runtime::SafeCmp<AclDataPacketBroadcastFlag> for i64 {
125    fn safe_eq(&self, other: AclDataPacketBroadcastFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
126    fn safe_less(&self, other: AclDataPacketBroadcastFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
127}
128
129impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for AclDataPacketBroadcastFlag {
130    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
131        let v_raw: u64 = val.into();
132        match v_raw {
133            0 => Ok(AclDataPacketBroadcastFlag::POINT_TO_POINT),
134            1 => Ok(AclDataPacketBroadcastFlag::BROADCAST),
135
136            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
137        }
138    }
139}
140
141impl AclDataPacketBroadcastFlag {
142
143}
144pub struct AclDataFrameHeader_EmbossReservedAnonymousField4<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
145    storage: S,
146    _marker: core::marker::PhantomData<ST>,
147}
148
149impl<S: emboss_runtime::Storage> AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::UncheckedState> {
150    pub fn new(storage: S) -> Self {
151        Self {
152            storage,
153            _marker: core::marker::PhantomData,
154        }
155    }
156}
157
158impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AclDataFrameHeader_EmbossReservedAnonymousField4<S, ST> {
159    fn clone(&self) -> Self {
160        Self {
161            storage: self.storage.clone(),
162            _marker: core::marker::PhantomData,
163        }
164    }
165}
166
167impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AclDataFrameHeader_EmbossReservedAnonymousField4<S, ST> {
168    /**
169     * Constructs a view in a specific typestate.
170     *
171     * # Safety
172     *
173     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
174     */
175    pub unsafe fn new_in_state(storage: S) -> Self {
176        Self {
177            storage,
178            _marker: core::marker::PhantomData,
179        }
180    }
181    pub fn into_storage(self) -> S {
182        self.storage
183    }
184    pub fn handle(&self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
185        let len = (2) as usize; // Total struct size in bytes
186        let storage = self.storage.slice(0, len);
187        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
188    }
189    pub fn packet_boundary_flag(&self) -> emboss_runtime::EnumView<AclDataPacketBoundaryFlag, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::Sliced<'_>, ST>> {
190        let len = (2) as usize;
191        let storage = self.storage.slice(0, len);
192        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
193    }
194    pub fn broadcast_flag(&self) -> emboss_runtime::EnumView<AclDataPacketBroadcastFlag, emboss_runtime::BitUInt<2, 14, emboss_runtime::Null, S::Sliced<'_>, ST>> {
195        let len = (2) as usize;
196        let storage = self.storage.slice(0, len);
197        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
198    }
199
200}
201
202pub struct AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S: emboss_runtime::MutStorage> {
203    storage: S,
204}
205
206impl<S: emboss_runtime::MutStorage> AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S> {
207    pub fn new(storage: S) -> Self {
208        Self {
209            storage,
210        }
211    }
212    pub fn into_writer(self) -> AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::UncheckedState> {
213        AclDataFrameHeader_EmbossReservedAnonymousField4Writer::new(self.storage)
214    }
215    /** Borrows the mutable view as an immutable view in UncheckedState. */
216    pub fn as_view(&self) -> AclDataFrameHeader_EmbossReservedAnonymousField4<S::Sliced<'_>, emboss_runtime::UncheckedState> {
217        unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(self.storage.slice(0, self.storage.len())) }
218    }
219    pub fn handle(&mut self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
220        let len = (2) as usize;
221        let storage = self.storage.slice_mut(0, len);
222        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
223    }
224    pub fn packet_boundary_flag(&mut self) -> emboss_runtime::EnumViewMut<AclDataPacketBoundaryFlag, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
225        let len = (2) as usize;
226        let storage = self.storage.slice_mut(0, len);
227        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
228    }
229    pub fn broadcast_flag(&mut self) -> emboss_runtime::EnumViewMut<AclDataPacketBroadcastFlag, emboss_runtime::BitUInt<2, 14, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
230        let len = (2) as usize;
231        let storage = self.storage.slice_mut(0, len);
232        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
233    }
234
235}
236
237impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S> {
238    type Writer = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::UncheckedState>;
239    fn into_writer(self) -> Self::Writer {
240        AclDataFrameHeader_EmbossReservedAnonymousField4Writer::new(self.storage)
241    }
242}
243
244pub struct AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
245    storage: S,
246    _marker: core::marker::PhantomData<ST>,
247}
248
249impl<S: emboss_runtime::MutStorage> AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::UncheckedState> {
250    pub fn new(storage: S) -> Self {
251        Self {
252            storage,
253            _marker: core::marker::PhantomData,
254        }
255    }
256}
257
258impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, ST> {
259    /**
260     * Constructs a writer in a specific typestate.
261     *
262     * # Safety
263     *
264     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
265     */
266    pub unsafe fn new_in_state(storage: S) -> Self {
267        Self {
268            storage,
269            _marker: core::marker::PhantomData,
270        }
271    }
272    pub fn into_storage(self) -> S {
273        self.storage
274    }
275    /** Converts the writer into an immutable view in the same typestate. */
276    pub fn into_view(self) -> AclDataFrameHeader_EmbossReservedAnonymousField4<S, ST> {
277        unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(self.storage) }
278    }
279    /** Borrows the writer as an immutable view in the same typestate. */
280    pub fn as_view(&self) -> AclDataFrameHeader_EmbossReservedAnonymousField4<S::Sliced<'_>, ST> {
281        unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(self.storage.slice(0, self.storage.len())) }
282    }
283
284}
285
286impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrameHeader_EmbossReservedAnonymousField4<S, ST> {
287    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
288        let view = self;
289        core::result::Result::Ok((((16) + 7) / 8) as usize)
290    }
291}
292
293impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S> {
294    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
295        let view = self.as_view();
296        <AclDataFrameHeader_EmbossReservedAnonymousField4<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
297    }
298}
299
300impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, ST> {
301    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
302        let view = self.as_view();
303        <AclDataFrameHeader_EmbossReservedAnonymousField4<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
304    }
305}
306
307impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::UncheckedState> {
308    type Completed = AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::CompleteState>;
309    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
310        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
311        if self.storage.len() < required_size {
312            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
313        }
314        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(self.storage) })
315    }
316}
317
318impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::UncheckedState> {
319    type Completed = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::CompleteState>;
320    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
321        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
322        if self.storage.len() < required_size {
323            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
324        }
325        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4Writer::new_in_state(self.storage) })
326    }
327}
328
329impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::UncheckedState> {
330    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::OkState>;
331    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
332        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
333        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(completed.into_storage()) })
334    }
335}
336
337impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::CompleteState> {
338    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::OkState>;
339    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
340        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::new_in_state(self.into_storage()) })
341    }
342}
343
344impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::OkState> {
345    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4<S, emboss_runtime::OkState>;
346    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
347        core::result::Result::Ok(self)
348    }
349}
350
351impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::UncheckedState> {
352    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::OkState>;
353    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
354        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
355        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4Writer::new_in_state(completed.into_storage()) })
356    }
357}
358
359impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::CompleteState> {
360    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::OkState>;
361    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
362        core::result::Result::Ok(unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4Writer::new_in_state(self.into_storage()) })
363    }
364}
365
366impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::OkState> {
367    type Ok = AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, emboss_runtime::OkState>;
368    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
369        core::result::Result::Ok(self)
370    }
371}
372
373pub mod acl_data_frame_header_emboss_reserved_anonymous_field4 {
374    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrameHeader_EmbossReservedAnonymousField4<S, ST>;
375    pub type ViewMut<S> = super::AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S>;
376    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrameHeader_EmbossReservedAnonymousField4Writer<S, ST>;
377
378    pub const MIN_SIZE_IN_BYTES: usize = 2;
379    pub const MAX_SIZE_IN_BYTES: usize = 2;
380    pub const SIZE_IN_BYTES: usize = 2;
381}pub struct AclDataFrameHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
382    storage: S,
383    _marker: core::marker::PhantomData<ST>,
384}
385
386impl<S: emboss_runtime::Storage> AclDataFrameHeader<S, emboss_runtime::UncheckedState> {
387    pub fn new(storage: S) -> Self {
388        Self {
389            storage,
390            _marker: core::marker::PhantomData,
391        }
392    }
393}
394
395impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AclDataFrameHeader<S, ST> {
396    fn clone(&self) -> Self {
397        Self {
398            storage: self.storage.clone(),
399            _marker: core::marker::PhantomData,
400        }
401    }
402}
403
404impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AclDataFrameHeader<S, ST> {
405    /**
406     * Constructs a view in a specific typestate.
407     *
408     * # Safety
409     *
410     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
411     */
412    pub unsafe fn new_in_state(storage: S) -> Self {
413        Self {
414            storage,
415            _marker: core::marker::PhantomData,
416        }
417    }
418    pub fn into_storage(self) -> S {
419        self.storage
420    }
421    pub fn emboss_reserved_anonymous_field_4(&self) -> AclDataFrameHeader_EmbossReservedAnonymousField4<S::Sliced<'_>, emboss_runtime::UncheckedState> {
422        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
423            let offset = (0) as usize;
424            let len = (2) as usize;
425            core::result::Result::Ok((offset, len))
426        })().unwrap_or((usize::MAX, 0));
427        let storage = self.storage.slice(offset, len);
428        unsafe { AclDataFrameHeader_EmbossReservedAnonymousField4::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
429    }
430    pub fn handle(&self) -> emboss_runtime::VirtualField<u64> {
431        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
432        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
433) as u64 )
434    })();
435        emboss_runtime::VirtualField::new(value)
436    }
437    pub fn packet_boundary_flag(&self) -> emboss_runtime::VirtualField<AclDataPacketBoundaryFlag> {
438        let value = (|| -> core::result::Result<AclDataPacketBoundaryFlag, emboss_runtime::Error> {
439        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().packet_boundary_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
440) as AclDataPacketBoundaryFlag )
441    })();
442        emboss_runtime::VirtualField::new(value)
443    }
444    pub fn broadcast_flag(&self) -> emboss_runtime::VirtualField<AclDataPacketBroadcastFlag> {
445        let value = (|| -> core::result::Result<AclDataPacketBroadcastFlag, emboss_runtime::Error> {
446        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().broadcast_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
447) as AclDataPacketBroadcastFlag )
448    })();
449        emboss_runtime::VirtualField::new(value)
450    }
451    pub fn data_total_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
452        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
453            let offset = (2) as usize;
454            let len = (2) as usize;
455            core::result::Result::Ok((offset, len))
456        })().unwrap_or((usize::MAX, 0));
457        let storage = self.storage.slice(offset, len);
458        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
459    }
460
461}
462
463pub struct AclDataFrameHeaderMut<S: emboss_runtime::MutStorage> {
464    storage: S,
465}
466
467impl<S: emboss_runtime::MutStorage> AclDataFrameHeaderMut<S> {
468    pub fn new(storage: S) -> Self {
469        Self {
470            storage,
471        }
472    }
473    pub fn into_writer(self) -> AclDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
474        AclDataFrameHeaderWriter::new(self.storage)
475    }
476    /** Borrows the mutable view as an immutable view in UncheckedState. */
477    pub fn as_view(&self) -> AclDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
478        unsafe { AclDataFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
479    }
480    pub fn emboss_reserved_anonymous_field_4(&mut self) -> AclDataFrameHeader_EmbossReservedAnonymousField4Mut<S::SlicedMut<'_>> {
481        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
482            let offset = (0) as usize;
483            let len = (2) as usize;
484            core::result::Result::Ok((offset, len))
485        })().unwrap_or((usize::MAX, 0));
486        let storage = self.storage.slice_mut(offset, len);
487        AclDataFrameHeader_EmbossReservedAnonymousField4Mut::<S::SlicedMut<'_>>::new(storage)
488    }
489    pub fn handle(&mut self) -> emboss_runtime::VirtualField<u64> {
490        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
491        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
492) as u64 )
493    })();
494        emboss_runtime::VirtualField::new(value)
495    }
496    pub fn packet_boundary_flag(&mut self) -> emboss_runtime::VirtualField<AclDataPacketBoundaryFlag> {
497        let value = (|| -> core::result::Result<AclDataPacketBoundaryFlag, emboss_runtime::Error> {
498        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().packet_boundary_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
499) as AclDataPacketBoundaryFlag )
500    })();
501        emboss_runtime::VirtualField::new(value)
502    }
503    pub fn broadcast_flag(&mut self) -> emboss_runtime::VirtualField<AclDataPacketBroadcastFlag> {
504        let value = (|| -> core::result::Result<AclDataPacketBroadcastFlag, emboss_runtime::Error> {
505        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_4().broadcast_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
506) as AclDataPacketBroadcastFlag )
507    })();
508        emboss_runtime::VirtualField::new(value)
509    }
510    pub fn data_total_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
511        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
512            let offset = (2) as usize;
513            let len = (2) as usize;
514            core::result::Result::Ok((offset, len))
515        })().unwrap_or((usize::MAX, 0));
516        let storage = self.storage.slice_mut(offset, len);
517        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
518    }
519
520}
521
522impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AclDataFrameHeaderMut<S> {
523    type Writer = AclDataFrameHeaderWriter<S, emboss_runtime::UncheckedState>;
524    fn into_writer(self) -> Self::Writer {
525        AclDataFrameHeaderWriter::new(self.storage)
526    }
527}
528
529pub struct AclDataFrameHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
530    storage: S,
531    _marker: core::marker::PhantomData<ST>,
532}
533
534impl<S: emboss_runtime::MutStorage> AclDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
535    pub fn new(storage: S) -> Self {
536        Self {
537            storage,
538            _marker: core::marker::PhantomData,
539        }
540    }
541}
542
543impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AclDataFrameHeaderWriter<S, ST> {
544    /**
545     * Constructs a writer in a specific typestate.
546     *
547     * # Safety
548     *
549     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
550     */
551    pub unsafe fn new_in_state(storage: S) -> Self {
552        Self {
553            storage,
554            _marker: core::marker::PhantomData,
555        }
556    }
557    pub fn into_storage(self) -> S {
558        self.storage
559    }
560    /** Converts the writer into an immutable view in the same typestate. */
561    pub fn into_view(self) -> AclDataFrameHeader<S, ST> {
562        unsafe { AclDataFrameHeader::new_in_state(self.storage) }
563    }
564    /** Borrows the writer as an immutable view in the same typestate. */
565    pub fn as_view(&self) -> AclDataFrameHeader<S::Sliced<'_>, ST> {
566        unsafe { AclDataFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
567    }
568    pub fn write_data_total_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> AclDataFrameHeaderWriter<S, ST::OnValidMutation> {
569        let view = self.into_view();
570        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
571            let offset = (2) as usize;
572            let len = (2) as usize;
573            core::result::Result::Ok((offset, len))
574        })().expect("valid layout in complete state");
575        let mut storage = view.into_storage();
576        {
577            let slice = storage.slice_mut(offset, len);
578            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
579            field_view.try_write(val).expect("valid write in complete state");
580        }
581        unsafe { AclDataFrameHeaderWriter::new_in_state(storage) }
582    }
583
584}
585
586impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrameHeader<S, ST> {
587    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
588        let view = self;
589        core::result::Result::Ok((4) as usize)
590    }
591}
592
593impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AclDataFrameHeaderMut<S> {
594    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
595        let view = self.as_view();
596        <AclDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
597    }
598}
599
600impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrameHeaderWriter<S, ST> {
601    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
602        let view = self.as_view();
603        <AclDataFrameHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
604    }
605}
606
607impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AclDataFrameHeader<S, emboss_runtime::UncheckedState> {
608    type Completed = AclDataFrameHeader<S, emboss_runtime::CompleteState>;
609    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
610        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
611        if self.storage.len() < required_size {
612            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
613        }
614        core::result::Result::Ok(unsafe { AclDataFrameHeader::new_in_state(self.storage) })
615    }
616}
617
618impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AclDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
619    type Completed = AclDataFrameHeaderWriter<S, emboss_runtime::CompleteState>;
620    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
621        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
622        if self.storage.len() < required_size {
623            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
624        }
625        core::result::Result::Ok(unsafe { AclDataFrameHeaderWriter::new_in_state(self.storage) })
626    }
627}
628
629impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader<S, emboss_runtime::UncheckedState> {
630    type Ok = AclDataFrameHeader<S, emboss_runtime::OkState>;
631    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
632        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
633        core::result::Result::Ok(unsafe { AclDataFrameHeader::new_in_state(completed.into_storage()) })
634    }
635}
636
637impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader<S, emboss_runtime::CompleteState> {
638    type Ok = AclDataFrameHeader<S, emboss_runtime::OkState>;
639    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
640        core::result::Result::Ok(unsafe { AclDataFrameHeader::new_in_state(self.into_storage()) })
641    }
642}
643
644impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrameHeader<S, emboss_runtime::OkState> {
645    type Ok = AclDataFrameHeader<S, emboss_runtime::OkState>;
646    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
647        core::result::Result::Ok(self)
648    }
649}
650
651impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
652    type Ok = AclDataFrameHeaderWriter<S, emboss_runtime::OkState>;
653    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
654        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
655        core::result::Result::Ok(unsafe { AclDataFrameHeaderWriter::new_in_state(completed.into_storage()) })
656    }
657}
658
659impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeaderWriter<S, emboss_runtime::CompleteState> {
660    type Ok = AclDataFrameHeaderWriter<S, emboss_runtime::OkState>;
661    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
662        core::result::Result::Ok(unsafe { AclDataFrameHeaderWriter::new_in_state(self.into_storage()) })
663    }
664}
665
666impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameHeaderWriter<S, emboss_runtime::OkState> {
667    type Ok = AclDataFrameHeaderWriter<S, emboss_runtime::OkState>;
668    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
669        core::result::Result::Ok(self)
670    }
671}
672
673pub mod acl_data_frame_header {
674    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrameHeader<S, ST>;
675    pub type ViewMut<S> = super::AclDataFrameHeaderMut<S>;
676    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrameHeaderWriter<S, ST>;
677
678    pub const MIN_SIZE_IN_BYTES: usize = 4;
679    pub const MAX_SIZE_IN_BYTES: usize = 4;
680    pub const SIZE_IN_BYTES: usize = 4;
681}pub struct AclDataFrame_Payload_ArrayView<S: emboss_runtime::Storage> {
682    storage: S,
683    element_count: usize,
684}
685
686impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for AclDataFrame_Payload_ArrayView<S> {
687    fn clone(&self) -> Self {
688        Self {
689            storage: self.storage.clone(),
690            element_count: self.element_count,
691        }
692    }
693}
694
695impl<S: emboss_runtime::Storage> AclDataFrame_Payload_ArrayView<S> {
696    pub const ELEMENT_SIZE_BYTES: usize = 1;
697    pub fn new(storage: S, element_count: usize) -> Self {
698        Self { storage, element_count }
699    }
700    pub fn element_count(&self) -> usize {
701        self.element_count
702    }
703    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
704, emboss_runtime::Error> {
705        if index >= self.element_count {
706            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
707        }
708        let offset = index * Self::ELEMENT_SIZE_BYTES;
709        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
710        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
711)
712    }
713}
714
715pub struct AclDataFrame_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
716    storage: S,
717    element_count: usize,
718}
719
720impl<S: emboss_runtime::MutStorage> AclDataFrame_Payload_ArrayViewMut<S> {
721    pub const ELEMENT_SIZE_BYTES: usize = 1;
722    pub fn new(storage: S, element_count: usize) -> Self {
723        Self { storage, element_count }
724    }
725    pub fn element_count(&self) -> usize {
726        self.element_count
727    }
728    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
729, emboss_runtime::Error> {
730        if index >= self.element_count {
731            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
732        }
733        let offset = index * Self::ELEMENT_SIZE_BYTES;
734        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
735        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
736)
737    }
738}
739pub struct AclDataFrame<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
740    storage: S,
741    _marker: core::marker::PhantomData<ST>,
742}
743
744impl<S: emboss_runtime::Storage> AclDataFrame<S, emboss_runtime::UncheckedState> {
745    pub fn new(storage: S) -> Self {
746        Self {
747            storage,
748            _marker: core::marker::PhantomData,
749        }
750    }
751}
752
753impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for AclDataFrame<S, ST> {
754    fn clone(&self) -> Self {
755        Self {
756            storage: self.storage.clone(),
757            _marker: core::marker::PhantomData,
758        }
759    }
760}
761
762impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> AclDataFrame<S, ST> {
763    /**
764     * Constructs a view in a specific typestate.
765     *
766     * # Safety
767     *
768     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
769     */
770    pub unsafe fn new_in_state(storage: S) -> Self {
771        Self {
772            storage,
773            _marker: core::marker::PhantomData,
774        }
775    }
776    pub fn into_storage(self) -> S {
777        self.storage
778    }
779    pub fn header(&self) -> AclDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
780        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
781            let offset = (0) as usize;
782            let len = (4) as usize;
783            core::result::Result::Ok((offset, len))
784        })().unwrap_or((usize::MAX, 0));
785        let storage = self.storage.slice(offset, len);
786        unsafe { AclDataFrameHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
787    }
788    pub fn data_total_length(&self) -> emboss_runtime::VirtualField<u64> {
789        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
790        core::result::Result::Ok( (({ let val = self.header().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
791) as u64 )
792    })();
793        emboss_runtime::VirtualField::new(value)
794    }
795    pub fn payload(&self) -> core::result::Result<AclDataFrame_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
796        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
797            let offset = (4) as usize;
798            let len = (({ let val = self.data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
799) as usize;
800            let element_count = (len / (1)) as usize;
801            core::result::Result::Ok((offset, len, element_count))
802        })();
803        match offset_res {
804            core::result::Result::Ok((offset, len, element_count)) => {
805                if len > 0 {
806                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
807                    self.storage.try_read_byte(end - 1)?;
808                }
809                let storage = self.storage.slice(offset, len);
810                core::result::Result::Ok(AclDataFrame_Payload_ArrayView::new(storage, element_count))
811            },
812            core::result::Result::Err(e) => core::result::Result::Err(e),
813        }
814    }
815
816}
817
818pub struct AclDataFrameMut<S: emboss_runtime::MutStorage> {
819    storage: S,
820}
821
822impl<S: emboss_runtime::MutStorage> AclDataFrameMut<S> {
823    pub fn new(storage: S) -> Self {
824        Self {
825            storage,
826        }
827    }
828    pub fn into_writer(self) -> AclDataFrameWriter<S, emboss_runtime::UncheckedState> {
829        AclDataFrameWriter::new(self.storage)
830    }
831    /** Borrows the mutable view as an immutable view in UncheckedState. */
832    pub fn as_view(&self) -> AclDataFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> {
833        unsafe { AclDataFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
834    }
835    pub fn header(&mut self) -> AclDataFrameHeaderMut<S::SlicedMut<'_>> {
836        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
837            let offset = (0) as usize;
838            let len = (4) as usize;
839            core::result::Result::Ok((offset, len))
840        })().unwrap_or((usize::MAX, 0));
841        let storage = self.storage.slice_mut(offset, len);
842        AclDataFrameHeaderMut::<S::SlicedMut<'_>>::new(storage)
843    }
844    pub fn data_total_length(&mut self) -> emboss_runtime::VirtualField<u64> {
845        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
846        core::result::Result::Ok( (({ let val = self.header().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
847) as u64 )
848    })();
849        emboss_runtime::VirtualField::new(value)
850    }
851    pub fn payload_mut(&mut self) -> core::result::Result<AclDataFrame_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
852        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
853            let offset = (4) as usize;
854            let len = (({ let val = self.data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
855) as usize;
856            let element_count = (len / (1)) as usize;
857            core::result::Result::Ok((offset, len, element_count))
858        })();
859        match offset_res {
860            core::result::Result::Ok((offset, len, element_count)) => {
861                if len > 0 {
862                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
863                    self.storage.try_read_byte(end - 1)?;
864                }
865                let storage = self.storage.slice_mut(offset, len);
866                core::result::Result::Ok(AclDataFrame_Payload_ArrayViewMut::new(storage, element_count))
867            },
868            core::result::Result::Err(e) => core::result::Result::Err(e),
869        }
870    }
871
872}
873
874impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for AclDataFrameMut<S> {
875    type Writer = AclDataFrameWriter<S, emboss_runtime::UncheckedState>;
876    fn into_writer(self) -> Self::Writer {
877        AclDataFrameWriter::new(self.storage)
878    }
879}
880
881pub struct AclDataFrameWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
882    storage: S,
883    _marker: core::marker::PhantomData<ST>,
884}
885
886impl<S: emboss_runtime::MutStorage> AclDataFrameWriter<S, emboss_runtime::UncheckedState> {
887    pub fn new(storage: S) -> Self {
888        Self {
889            storage,
890            _marker: core::marker::PhantomData,
891        }
892    }
893}
894
895impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> AclDataFrameWriter<S, ST> {
896    /**
897     * Constructs a writer in a specific typestate.
898     *
899     * # Safety
900     *
901     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
902     */
903    pub unsafe fn new_in_state(storage: S) -> Self {
904        Self {
905            storage,
906            _marker: core::marker::PhantomData,
907        }
908    }
909    pub fn into_storage(self) -> S {
910        self.storage
911    }
912    /** Converts the writer into an immutable view in the same typestate. */
913    pub fn into_view(self) -> AclDataFrame<S, ST> {
914        unsafe { AclDataFrame::new_in_state(self.storage) }
915    }
916    /** Borrows the writer as an immutable view in the same typestate. */
917    pub fn as_view(&self) -> AclDataFrame<S::Sliced<'_>, ST> {
918        unsafe { AclDataFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
919    }
920
921}
922
923impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrame<S, ST> {
924    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
925        let view = self;
926        core::result::Result::Ok((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
927) as i64, ((if true { ( (4) as i64 + (({ let val = view.data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
928) as i64 )
929 } else { 0 })
930
931) as i64)
932) as usize)
933    }
934}
935
936impl<S: emboss_runtime::MutStorage> emboss_runtime::View for AclDataFrameMut<S> {
937    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
938        let view = self.as_view();
939        <AclDataFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
940    }
941}
942
943impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for AclDataFrameWriter<S, ST> {
944    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
945        let view = self.as_view();
946        <AclDataFrame<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
947    }
948}
949
950impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for AclDataFrame<S, emboss_runtime::UncheckedState> {
951    type Completed = AclDataFrame<S, emboss_runtime::CompleteState>;
952    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
953        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
954        if self.storage.len() < required_size {
955            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
956        }
957        core::result::Result::Ok(unsafe { AclDataFrame::new_in_state(self.storage) })
958    }
959}
960
961impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for AclDataFrameWriter<S, emboss_runtime::UncheckedState> {
962    type Completed = AclDataFrameWriter<S, emboss_runtime::CompleteState>;
963    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
964        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
965        if self.storage.len() < required_size {
966            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
967        }
968        core::result::Result::Ok(unsafe { AclDataFrameWriter::new_in_state(self.storage) })
969    }
970}
971
972impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrame<S, emboss_runtime::UncheckedState> {
973    type Ok = AclDataFrame<S, emboss_runtime::OkState>;
974    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
975        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
976        core::result::Result::Ok(unsafe { AclDataFrame::new_in_state(completed.into_storage()) })
977    }
978}
979
980impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrame<S, emboss_runtime::CompleteState> {
981    type Ok = AclDataFrame<S, emboss_runtime::OkState>;
982    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
983        core::result::Result::Ok(unsafe { AclDataFrame::new_in_state(self.into_storage()) })
984    }
985}
986
987impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for AclDataFrame<S, emboss_runtime::OkState> {
988    type Ok = AclDataFrame<S, emboss_runtime::OkState>;
989    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
990        core::result::Result::Ok(self)
991    }
992}
993
994impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameWriter<S, emboss_runtime::UncheckedState> {
995    type Ok = AclDataFrameWriter<S, emboss_runtime::OkState>;
996    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
997        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
998        core::result::Result::Ok(unsafe { AclDataFrameWriter::new_in_state(completed.into_storage()) })
999    }
1000}
1001
1002impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameWriter<S, emboss_runtime::CompleteState> {
1003    type Ok = AclDataFrameWriter<S, emboss_runtime::OkState>;
1004    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1005        core::result::Result::Ok(unsafe { AclDataFrameWriter::new_in_state(self.into_storage()) })
1006    }
1007}
1008
1009impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for AclDataFrameWriter<S, emboss_runtime::OkState> {
1010    type Ok = AclDataFrameWriter<S, emboss_runtime::OkState>;
1011    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1012        core::result::Result::Ok(self)
1013    }
1014}
1015
1016pub mod acl_data_frame {
1017    pub type View<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrame<S, ST>;
1018    pub type ViewMut<S> = super::AclDataFrameMut<S>;
1019    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::AclDataFrameWriter<S, ST>;
1020
1021    pub const MIN_SIZE_IN_BYTES: usize = 4;
1022    pub const MAX_SIZE_IN_BYTES: usize = 65539;
1023}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
1024#[repr(u64)]
1025pub enum TsFlag {
1026    TIMESTAMP_NOT_PRESENT = 0,
1027    TIMESTAMP_PRESENT = 1,
1028
1029}
1030
1031impl core::convert::From<TsFlag> for u8 { fn from(val: TsFlag) -> Self { val as u8 } }
1032impl core::convert::From<TsFlag> for u16 { fn from(val: TsFlag) -> Self { val as u16 } }
1033impl core::convert::From<TsFlag> for u32 { fn from(val: TsFlag) -> Self { val as u32 } }
1034impl core::convert::From<TsFlag> for u64 { fn from(val: TsFlag) -> Self { val as u64 } }
1035impl core::convert::From<TsFlag> for i8 { fn from(val: TsFlag) -> Self { val as i8 } }
1036impl core::convert::From<TsFlag> for i16 { fn from(val: TsFlag) -> Self { val as i16 } }
1037impl core::convert::From<TsFlag> for i32 { fn from(val: TsFlag) -> Self { val as i32 } }
1038impl core::convert::From<TsFlag> for i64 { fn from(val: TsFlag) -> Self { val as i64 } }
1039
1040impl emboss_runtime::SafeCmp<TsFlag> for TsFlag {
1041    fn safe_eq(&self, other: Self) -> bool { *self == other }
1042    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
1043}
1044
1045impl emboss_runtime::SafeCmp<u64> for TsFlag {
1046    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1047    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1048}
1049
1050impl emboss_runtime::SafeCmp<i64> for TsFlag {
1051    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1052    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1053}
1054
1055impl emboss_runtime::SafeCmp<i32> for TsFlag {
1056    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
1057    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
1058}
1059
1060impl emboss_runtime::SafeCmp<u32> for TsFlag {
1061    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
1062    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
1063}
1064
1065impl emboss_runtime::SafeCmp<TsFlag> for u64 {
1066    fn safe_eq(&self, other: TsFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1067    fn safe_less(&self, other: TsFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1068}
1069
1070impl emboss_runtime::SafeCmp<TsFlag> for i64 {
1071    fn safe_eq(&self, other: TsFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1072    fn safe_less(&self, other: TsFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1073}
1074
1075impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for TsFlag {
1076    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
1077        let v_raw: u64 = val.into();
1078        match v_raw {
1079            0 => Ok(TsFlag::TIMESTAMP_NOT_PRESENT),
1080            1 => Ok(TsFlag::TIMESTAMP_PRESENT),
1081
1082            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
1083        }
1084    }
1085}
1086
1087impl TsFlag {
1088
1089}
1090#[derive(Copy, Clone, Debug, Eq, PartialEq)]
1091#[repr(u64)]
1092pub enum IsoDataPbFlag {
1093    FIRST_FRAGMENT = 0,
1094    INTERMEDIATE_FRAGMENT = 1,
1095    COMPLETE_SDU = 2,
1096    LAST_FRAGMENT = 3,
1097
1098}
1099
1100impl core::convert::From<IsoDataPbFlag> for u8 { fn from(val: IsoDataPbFlag) -> Self { val as u8 } }
1101impl core::convert::From<IsoDataPbFlag> for u16 { fn from(val: IsoDataPbFlag) -> Self { val as u16 } }
1102impl core::convert::From<IsoDataPbFlag> for u32 { fn from(val: IsoDataPbFlag) -> Self { val as u32 } }
1103impl core::convert::From<IsoDataPbFlag> for u64 { fn from(val: IsoDataPbFlag) -> Self { val as u64 } }
1104impl core::convert::From<IsoDataPbFlag> for i8 { fn from(val: IsoDataPbFlag) -> Self { val as i8 } }
1105impl core::convert::From<IsoDataPbFlag> for i16 { fn from(val: IsoDataPbFlag) -> Self { val as i16 } }
1106impl core::convert::From<IsoDataPbFlag> for i32 { fn from(val: IsoDataPbFlag) -> Self { val as i32 } }
1107impl core::convert::From<IsoDataPbFlag> for i64 { fn from(val: IsoDataPbFlag) -> Self { val as i64 } }
1108
1109impl emboss_runtime::SafeCmp<IsoDataPbFlag> for IsoDataPbFlag {
1110    fn safe_eq(&self, other: Self) -> bool { *self == other }
1111    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
1112}
1113
1114impl emboss_runtime::SafeCmp<u64> for IsoDataPbFlag {
1115    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1116    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1117}
1118
1119impl emboss_runtime::SafeCmp<i64> for IsoDataPbFlag {
1120    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1121    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1122}
1123
1124impl emboss_runtime::SafeCmp<i32> for IsoDataPbFlag {
1125    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
1126    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
1127}
1128
1129impl emboss_runtime::SafeCmp<u32> for IsoDataPbFlag {
1130    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
1131    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
1132}
1133
1134impl emboss_runtime::SafeCmp<IsoDataPbFlag> for u64 {
1135    fn safe_eq(&self, other: IsoDataPbFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1136    fn safe_less(&self, other: IsoDataPbFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1137}
1138
1139impl emboss_runtime::SafeCmp<IsoDataPbFlag> for i64 {
1140    fn safe_eq(&self, other: IsoDataPbFlag) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1141    fn safe_less(&self, other: IsoDataPbFlag) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1142}
1143
1144impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for IsoDataPbFlag {
1145    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
1146        let v_raw: u64 = val.into();
1147        match v_raw {
1148            0 => Ok(IsoDataPbFlag::FIRST_FRAGMENT),
1149            1 => Ok(IsoDataPbFlag::INTERMEDIATE_FRAGMENT),
1150            2 => Ok(IsoDataPbFlag::COMPLETE_SDU),
1151            3 => Ok(IsoDataPbFlag::LAST_FRAGMENT),
1152
1153            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
1154        }
1155    }
1156}
1157
1158impl IsoDataPbFlag {
1159
1160}
1161#[derive(Copy, Clone, Debug, Eq, PartialEq)]
1162#[repr(u64)]
1163pub enum IsoDataPacketStatus {
1164    VALID_DATA = 0,
1165    POSSIBLY_INVALID_DATA = 1,
1166    LOST_DATA = 2,
1167
1168}
1169
1170impl core::convert::From<IsoDataPacketStatus> for u8 { fn from(val: IsoDataPacketStatus) -> Self { val as u8 } }
1171impl core::convert::From<IsoDataPacketStatus> for u16 { fn from(val: IsoDataPacketStatus) -> Self { val as u16 } }
1172impl core::convert::From<IsoDataPacketStatus> for u32 { fn from(val: IsoDataPacketStatus) -> Self { val as u32 } }
1173impl core::convert::From<IsoDataPacketStatus> for u64 { fn from(val: IsoDataPacketStatus) -> Self { val as u64 } }
1174impl core::convert::From<IsoDataPacketStatus> for i8 { fn from(val: IsoDataPacketStatus) -> Self { val as i8 } }
1175impl core::convert::From<IsoDataPacketStatus> for i16 { fn from(val: IsoDataPacketStatus) -> Self { val as i16 } }
1176impl core::convert::From<IsoDataPacketStatus> for i32 { fn from(val: IsoDataPacketStatus) -> Self { val as i32 } }
1177impl core::convert::From<IsoDataPacketStatus> for i64 { fn from(val: IsoDataPacketStatus) -> Self { val as i64 } }
1178
1179impl emboss_runtime::SafeCmp<IsoDataPacketStatus> for IsoDataPacketStatus {
1180    fn safe_eq(&self, other: Self) -> bool { *self == other }
1181    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
1182}
1183
1184impl emboss_runtime::SafeCmp<u64> for IsoDataPacketStatus {
1185    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1186    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1187}
1188
1189impl emboss_runtime::SafeCmp<i64> for IsoDataPacketStatus {
1190    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
1191    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
1192}
1193
1194impl emboss_runtime::SafeCmp<i32> for IsoDataPacketStatus {
1195    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
1196    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
1197}
1198
1199impl emboss_runtime::SafeCmp<u32> for IsoDataPacketStatus {
1200    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
1201    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
1202}
1203
1204impl emboss_runtime::SafeCmp<IsoDataPacketStatus> for u64 {
1205    fn safe_eq(&self, other: IsoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1206    fn safe_less(&self, other: IsoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1207}
1208
1209impl emboss_runtime::SafeCmp<IsoDataPacketStatus> for i64 {
1210    fn safe_eq(&self, other: IsoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
1211    fn safe_less(&self, other: IsoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
1212}
1213
1214impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for IsoDataPacketStatus {
1215    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
1216        let v_raw: u64 = val.into();
1217        match v_raw {
1218            0 => Ok(IsoDataPacketStatus::VALID_DATA),
1219            1 => Ok(IsoDataPacketStatus::POSSIBLY_INVALID_DATA),
1220            2 => Ok(IsoDataPacketStatus::LOST_DATA),
1221
1222            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
1223        }
1224    }
1225}
1226
1227impl IsoDataPacketStatus {
1228
1229}
1230pub struct IsoDataFrameHeader_EmbossReservedAnonymousField3<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1231    storage: S,
1232    _marker: core::marker::PhantomData<ST>,
1233}
1234
1235impl<S: emboss_runtime::Storage> IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::UncheckedState> {
1236    pub fn new(storage: S) -> Self {
1237        Self {
1238            storage,
1239            _marker: core::marker::PhantomData,
1240        }
1241    }
1242}
1243
1244impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, ST> {
1245    fn clone(&self) -> Self {
1246        Self {
1247            storage: self.storage.clone(),
1248            _marker: core::marker::PhantomData,
1249        }
1250    }
1251}
1252
1253impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> IsoDataFrameHeader_EmbossReservedAnonymousField3<S, ST> {
1254    /**
1255     * Constructs a view in a specific typestate.
1256     *
1257     * # Safety
1258     *
1259     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1260     */
1261    pub unsafe fn new_in_state(storage: S) -> Self {
1262        Self {
1263            storage,
1264            _marker: core::marker::PhantomData,
1265        }
1266    }
1267    pub fn into_storage(self) -> S {
1268        self.storage
1269    }
1270    pub fn connection_handle(&self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
1271        let len = (2) as usize; // Total struct size in bytes
1272        let storage = self.storage.slice(0, len);
1273        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
1274    }
1275    pub fn pb_flag(&self) -> emboss_runtime::EnumView<IsoDataPbFlag, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::Sliced<'_>, ST>> {
1276        let len = (2) as usize;
1277        let storage = self.storage.slice(0, len);
1278        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
1279    }
1280    pub fn ts_flag(&self) -> emboss_runtime::EnumView<TsFlag, emboss_runtime::BitUInt<1, 14, emboss_runtime::Null, S::Sliced<'_>, ST>> {
1281        let len = (2) as usize;
1282        let storage = self.storage.slice(0, len);
1283        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
1284    }
1285    pub fn data_total_length(&self) -> emboss_runtime::BitUInt<14, 16, emboss_runtime::Null, S::Sliced<'_>, ST> {
1286        let len = (4) as usize; // Total struct size in bytes
1287        let storage = self.storage.slice(0, len);
1288        emboss_runtime::BitUInt::<14, 16, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
1289    }
1290
1291}
1292
1293pub struct IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S: emboss_runtime::MutStorage> {
1294    storage: S,
1295}
1296
1297impl<S: emboss_runtime::MutStorage> IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S> {
1298    pub fn new(storage: S) -> Self {
1299        Self {
1300            storage,
1301        }
1302    }
1303    pub fn into_writer(self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::UncheckedState> {
1304        IsoDataFrameHeader_EmbossReservedAnonymousField3Writer::new(self.storage)
1305    }
1306    /** Borrows the mutable view as an immutable view in UncheckedState. */
1307    pub fn as_view(&self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1308        unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(self.storage.slice(0, self.storage.len())) }
1309    }
1310    pub fn connection_handle(&mut self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1311        let len = (2) as usize;
1312        let storage = self.storage.slice_mut(0, len);
1313        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1314    }
1315    pub fn pb_flag(&mut self) -> emboss_runtime::EnumViewMut<IsoDataPbFlag, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1316        let len = (2) as usize;
1317        let storage = self.storage.slice_mut(0, len);
1318        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
1319    }
1320    pub fn ts_flag(&mut self) -> emboss_runtime::EnumViewMut<TsFlag, emboss_runtime::BitUInt<1, 14, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1321        let len = (2) as usize;
1322        let storage = self.storage.slice_mut(0, len);
1323        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
1324    }
1325    pub fn data_total_length(&mut self) -> emboss_runtime::BitUInt<14, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1326        let len = (4) as usize;
1327        let storage = self.storage.slice_mut(0, len);
1328        emboss_runtime::BitUInt::<14, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1329    }
1330
1331}
1332
1333impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S> {
1334    type Writer = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::UncheckedState>;
1335    fn into_writer(self) -> Self::Writer {
1336        IsoDataFrameHeader_EmbossReservedAnonymousField3Writer::new(self.storage)
1337    }
1338}
1339
1340pub struct IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1341    storage: S,
1342    _marker: core::marker::PhantomData<ST>,
1343}
1344
1345impl<S: emboss_runtime::MutStorage> IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::UncheckedState> {
1346    pub fn new(storage: S) -> Self {
1347        Self {
1348            storage,
1349            _marker: core::marker::PhantomData,
1350        }
1351    }
1352}
1353
1354impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, ST> {
1355    /**
1356     * Constructs a writer in a specific typestate.
1357     *
1358     * # Safety
1359     *
1360     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1361     */
1362    pub unsafe fn new_in_state(storage: S) -> Self {
1363        Self {
1364            storage,
1365            _marker: core::marker::PhantomData,
1366        }
1367    }
1368    pub fn into_storage(self) -> S {
1369        self.storage
1370    }
1371    /** Converts the writer into an immutable view in the same typestate. */
1372    pub fn into_view(self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3<S, ST> {
1373        unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(self.storage) }
1374    }
1375    /** Borrows the writer as an immutable view in the same typestate. */
1376    pub fn as_view(&self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3<S::Sliced<'_>, ST> {
1377        unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(self.storage.slice(0, self.storage.len())) }
1378    }
1379
1380}
1381
1382impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, ST> {
1383    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1384        let view = self;
1385        core::result::Result::Ok((((30) + 7) / 8) as usize)
1386    }
1387}
1388
1389impl<S: emboss_runtime::MutStorage> emboss_runtime::View for IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S> {
1390    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1391        let view = self.as_view();
1392        <IsoDataFrameHeader_EmbossReservedAnonymousField3<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1393    }
1394}
1395
1396impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, ST> {
1397    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1398        let view = self.as_view();
1399        <IsoDataFrameHeader_EmbossReservedAnonymousField3<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1400    }
1401}
1402
1403impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::UncheckedState> {
1404    type Completed = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::CompleteState>;
1405    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1406        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1407        if self.storage.len() < required_size {
1408            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1409        }
1410        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(self.storage) })
1411    }
1412}
1413
1414impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::UncheckedState> {
1415    type Completed = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::CompleteState>;
1416    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1417        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1418        if self.storage.len() < required_size {
1419            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1420        }
1421        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3Writer::new_in_state(self.storage) })
1422    }
1423}
1424
1425impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::UncheckedState> {
1426    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::OkState>;
1427    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1428        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1429        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(completed.into_storage()) })
1430    }
1431}
1432
1433impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::CompleteState> {
1434    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::OkState>;
1435    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1436        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::new_in_state(self.into_storage()) })
1437    }
1438}
1439
1440impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::OkState> {
1441    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3<S, emboss_runtime::OkState>;
1442    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1443        core::result::Result::Ok(self)
1444    }
1445}
1446
1447impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::UncheckedState> {
1448    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::OkState>;
1449    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1450        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1451        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3Writer::new_in_state(completed.into_storage()) })
1452    }
1453}
1454
1455impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::CompleteState> {
1456    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::OkState>;
1457    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1458        core::result::Result::Ok(unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3Writer::new_in_state(self.into_storage()) })
1459    }
1460}
1461
1462impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::OkState> {
1463    type Ok = IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, emboss_runtime::OkState>;
1464    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1465        core::result::Result::Ok(self)
1466    }
1467}
1468
1469pub mod iso_data_frame_header_emboss_reserved_anonymous_field3 {
1470    pub type View<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFrameHeader_EmbossReservedAnonymousField3<S, ST>;
1471    pub type ViewMut<S> = super::IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S>;
1472    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFrameHeader_EmbossReservedAnonymousField3Writer<S, ST>;
1473
1474    pub const MIN_SIZE_IN_BYTES: usize = 4;
1475    pub const MAX_SIZE_IN_BYTES: usize = 4;
1476    pub const SIZE_IN_BYTES: usize = 4;
1477}pub struct IsoDataFrameHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1478    storage: S,
1479    _marker: core::marker::PhantomData<ST>,
1480}
1481
1482impl<S: emboss_runtime::Storage> IsoDataFrameHeader<S, emboss_runtime::UncheckedState> {
1483    pub fn new(storage: S) -> Self {
1484        Self {
1485            storage,
1486            _marker: core::marker::PhantomData,
1487        }
1488    }
1489}
1490
1491impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for IsoDataFrameHeader<S, ST> {
1492    fn clone(&self) -> Self {
1493        Self {
1494            storage: self.storage.clone(),
1495            _marker: core::marker::PhantomData,
1496        }
1497    }
1498}
1499
1500impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> IsoDataFrameHeader<S, ST> {
1501    /**
1502     * Constructs a view in a specific typestate.
1503     *
1504     * # Safety
1505     *
1506     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1507     */
1508    pub unsafe fn new_in_state(storage: S) -> Self {
1509        Self {
1510            storage,
1511            _marker: core::marker::PhantomData,
1512        }
1513    }
1514    pub fn into_storage(self) -> S {
1515        self.storage
1516    }
1517    pub fn emboss_reserved_anonymous_field_3(&self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1518        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1519            let offset = (0) as usize;
1520            let len = (4) as usize;
1521            core::result::Result::Ok((offset, len))
1522        })().unwrap_or((usize::MAX, 0));
1523        let storage = self.storage.slice(offset, len);
1524        unsafe { IsoDataFrameHeader_EmbossReservedAnonymousField3::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
1525    }
1526    pub fn connection_handle(&self) -> emboss_runtime::VirtualField<u64> {
1527        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
1528        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().connection_handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1529) as u64 )
1530    })();
1531        emboss_runtime::VirtualField::new(value)
1532    }
1533    pub fn pb_flag(&self) -> emboss_runtime::VirtualField<IsoDataPbFlag> {
1534        let value = (|| -> core::result::Result<IsoDataPbFlag, emboss_runtime::Error> {
1535        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().pb_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1536) as IsoDataPbFlag )
1537    })();
1538        emboss_runtime::VirtualField::new(value)
1539    }
1540    pub fn ts_flag(&self) -> emboss_runtime::VirtualField<TsFlag> {
1541        let value = (|| -> core::result::Result<TsFlag, emboss_runtime::Error> {
1542        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().ts_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1543) as TsFlag )
1544    })();
1545        emboss_runtime::VirtualField::new(value)
1546    }
1547    pub fn data_total_length(&self) -> emboss_runtime::VirtualField<u64> {
1548        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
1549        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1550) as u64 )
1551    })();
1552        emboss_runtime::VirtualField::new(value)
1553    }
1554
1555}
1556
1557pub struct IsoDataFrameHeaderMut<S: emboss_runtime::MutStorage> {
1558    storage: S,
1559}
1560
1561impl<S: emboss_runtime::MutStorage> IsoDataFrameHeaderMut<S> {
1562    pub fn new(storage: S) -> Self {
1563        Self {
1564            storage,
1565        }
1566    }
1567    pub fn into_writer(self) -> IsoDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
1568        IsoDataFrameHeaderWriter::new(self.storage)
1569    }
1570    /** Borrows the mutable view as an immutable view in UncheckedState. */
1571    pub fn as_view(&self) -> IsoDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1572        unsafe { IsoDataFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
1573    }
1574    pub fn emboss_reserved_anonymous_field_3(&mut self) -> IsoDataFrameHeader_EmbossReservedAnonymousField3Mut<S::SlicedMut<'_>> {
1575        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
1576            let offset = (0) as usize;
1577            let len = (4) as usize;
1578            core::result::Result::Ok((offset, len))
1579        })().unwrap_or((usize::MAX, 0));
1580        let storage = self.storage.slice_mut(offset, len);
1581        IsoDataFrameHeader_EmbossReservedAnonymousField3Mut::<S::SlicedMut<'_>>::new(storage)
1582    }
1583    pub fn connection_handle(&mut self) -> emboss_runtime::VirtualField<u64> {
1584        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
1585        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().connection_handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1586) as u64 )
1587    })();
1588        emboss_runtime::VirtualField::new(value)
1589    }
1590    pub fn pb_flag(&mut self) -> emboss_runtime::VirtualField<IsoDataPbFlag> {
1591        let value = (|| -> core::result::Result<IsoDataPbFlag, emboss_runtime::Error> {
1592        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().pb_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1593) as IsoDataPbFlag )
1594    })();
1595        emboss_runtime::VirtualField::new(value)
1596    }
1597    pub fn ts_flag(&mut self) -> emboss_runtime::VirtualField<TsFlag> {
1598        let value = (|| -> core::result::Result<TsFlag, emboss_runtime::Error> {
1599        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().ts_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1600) as TsFlag )
1601    })();
1602        emboss_runtime::VirtualField::new(value)
1603    }
1604    pub fn data_total_length(&mut self) -> emboss_runtime::VirtualField<u64> {
1605        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
1606        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_3().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
1607) as u64 )
1608    })();
1609        emboss_runtime::VirtualField::new(value)
1610    }
1611
1612}
1613
1614impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for IsoDataFrameHeaderMut<S> {
1615    type Writer = IsoDataFrameHeaderWriter<S, emboss_runtime::UncheckedState>;
1616    fn into_writer(self) -> Self::Writer {
1617        IsoDataFrameHeaderWriter::new(self.storage)
1618    }
1619}
1620
1621pub struct IsoDataFrameHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1622    storage: S,
1623    _marker: core::marker::PhantomData<ST>,
1624}
1625
1626impl<S: emboss_runtime::MutStorage> IsoDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
1627    pub fn new(storage: S) -> Self {
1628        Self {
1629            storage,
1630            _marker: core::marker::PhantomData,
1631        }
1632    }
1633}
1634
1635impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> IsoDataFrameHeaderWriter<S, ST> {
1636    /**
1637     * Constructs a writer in a specific typestate.
1638     *
1639     * # Safety
1640     *
1641     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1642     */
1643    pub unsafe fn new_in_state(storage: S) -> Self {
1644        Self {
1645            storage,
1646            _marker: core::marker::PhantomData,
1647        }
1648    }
1649    pub fn into_storage(self) -> S {
1650        self.storage
1651    }
1652    /** Converts the writer into an immutable view in the same typestate. */
1653    pub fn into_view(self) -> IsoDataFrameHeader<S, ST> {
1654        unsafe { IsoDataFrameHeader::new_in_state(self.storage) }
1655    }
1656    /** Borrows the writer as an immutable view in the same typestate. */
1657    pub fn as_view(&self) -> IsoDataFrameHeader<S::Sliced<'_>, ST> {
1658        unsafe { IsoDataFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
1659    }
1660
1661}
1662
1663impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFrameHeader<S, ST> {
1664    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1665        let view = self;
1666        core::result::Result::Ok((4) as usize)
1667    }
1668}
1669
1670impl<S: emboss_runtime::MutStorage> emboss_runtime::View for IsoDataFrameHeaderMut<S> {
1671    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1672        let view = self.as_view();
1673        <IsoDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1674    }
1675}
1676
1677impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFrameHeaderWriter<S, ST> {
1678    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1679        let view = self.as_view();
1680        <IsoDataFrameHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1681    }
1682}
1683
1684impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for IsoDataFrameHeader<S, emboss_runtime::UncheckedState> {
1685    type Completed = IsoDataFrameHeader<S, emboss_runtime::CompleteState>;
1686    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1687        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1688        if self.storage.len() < required_size {
1689            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1690        }
1691        core::result::Result::Ok(unsafe { IsoDataFrameHeader::new_in_state(self.storage) })
1692    }
1693}
1694
1695impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for IsoDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
1696    type Completed = IsoDataFrameHeaderWriter<S, emboss_runtime::CompleteState>;
1697    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1698        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1699        if self.storage.len() < required_size {
1700            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1701        }
1702        core::result::Result::Ok(unsafe { IsoDataFrameHeaderWriter::new_in_state(self.storage) })
1703    }
1704}
1705
1706impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader<S, emboss_runtime::UncheckedState> {
1707    type Ok = IsoDataFrameHeader<S, emboss_runtime::OkState>;
1708    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1709        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1710        core::result::Result::Ok(unsafe { IsoDataFrameHeader::new_in_state(completed.into_storage()) })
1711    }
1712}
1713
1714impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader<S, emboss_runtime::CompleteState> {
1715    type Ok = IsoDataFrameHeader<S, emboss_runtime::OkState>;
1716    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1717        core::result::Result::Ok(unsafe { IsoDataFrameHeader::new_in_state(self.into_storage()) })
1718    }
1719}
1720
1721impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFrameHeader<S, emboss_runtime::OkState> {
1722    type Ok = IsoDataFrameHeader<S, emboss_runtime::OkState>;
1723    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1724        core::result::Result::Ok(self)
1725    }
1726}
1727
1728impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
1729    type Ok = IsoDataFrameHeaderWriter<S, emboss_runtime::OkState>;
1730    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1731        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1732        core::result::Result::Ok(unsafe { IsoDataFrameHeaderWriter::new_in_state(completed.into_storage()) })
1733    }
1734}
1735
1736impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeaderWriter<S, emboss_runtime::CompleteState> {
1737    type Ok = IsoDataFrameHeaderWriter<S, emboss_runtime::OkState>;
1738    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1739        core::result::Result::Ok(unsafe { IsoDataFrameHeaderWriter::new_in_state(self.into_storage()) })
1740    }
1741}
1742
1743impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFrameHeaderWriter<S, emboss_runtime::OkState> {
1744    type Ok = IsoDataFrameHeaderWriter<S, emboss_runtime::OkState>;
1745    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1746        core::result::Result::Ok(self)
1747    }
1748}
1749
1750pub mod iso_data_frame_header {
1751    pub type View<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFrameHeader<S, ST>;
1752    pub type ViewMut<S> = super::IsoDataFrameHeaderMut<S>;
1753    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFrameHeaderWriter<S, ST>;
1754
1755    pub const MIN_SIZE_IN_BYTES: usize = 4;
1756    pub const MAX_SIZE_IN_BYTES: usize = 4;
1757    pub const SIZE_IN_BYTES: usize = 4;
1758}pub struct IsoDataFramePacket_EmbossReservedAnonymousField2<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1759    storage: S,
1760    _marker: core::marker::PhantomData<ST>,
1761}
1762
1763impl<S: emboss_runtime::Storage> IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
1764    pub fn new(storage: S) -> Self {
1765        Self {
1766            storage,
1767            _marker: core::marker::PhantomData,
1768        }
1769    }
1770}
1771
1772impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for IsoDataFramePacket_EmbossReservedAnonymousField2<S, ST> {
1773    fn clone(&self) -> Self {
1774        Self {
1775            storage: self.storage.clone(),
1776            _marker: core::marker::PhantomData,
1777        }
1778    }
1779}
1780
1781impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> IsoDataFramePacket_EmbossReservedAnonymousField2<S, ST> {
1782    /**
1783     * Constructs a view in a specific typestate.
1784     *
1785     * # Safety
1786     *
1787     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1788     */
1789    pub unsafe fn new_in_state(storage: S) -> Self {
1790        Self {
1791            storage,
1792            _marker: core::marker::PhantomData,
1793        }
1794    }
1795    pub fn into_storage(self) -> S {
1796        self.storage
1797    }
1798    pub fn packet_sequence_number(&self) -> emboss_runtime::BitUInt<16, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
1799        let len = (2) as usize; // Total struct size in bytes
1800        let storage = self.storage.slice(0, len);
1801        emboss_runtime::BitUInt::<16, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
1802    }
1803    pub fn iso_sdu_length(&self) -> emboss_runtime::BitUInt<12, 16, emboss_runtime::Null, S::Sliced<'_>, ST> {
1804        let len = (4) as usize; // Total struct size in bytes
1805        let storage = self.storage.slice(0, len);
1806        emboss_runtime::BitUInt::<12, 16, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
1807    }
1808    pub fn packet_status_flag(&self) -> emboss_runtime::EnumView<IsoDataPacketStatus, emboss_runtime::BitUInt<2, 30, emboss_runtime::Null, S::Sliced<'_>, ST>> {
1809        let len = (4) as usize;
1810        let storage = self.storage.slice(0, len);
1811        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
1812    }
1813
1814}
1815
1816pub struct IsoDataFramePacket_EmbossReservedAnonymousField2Mut<S: emboss_runtime::MutStorage> {
1817    storage: S,
1818}
1819
1820impl<S: emboss_runtime::MutStorage> IsoDataFramePacket_EmbossReservedAnonymousField2Mut<S> {
1821    pub fn new(storage: S) -> Self {
1822        Self {
1823            storage,
1824        }
1825    }
1826    pub fn into_writer(self) -> IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
1827        IsoDataFramePacket_EmbossReservedAnonymousField2Writer::new(self.storage)
1828    }
1829    /** Borrows the mutable view as an immutable view in UncheckedState. */
1830    pub fn as_view(&self) -> IsoDataFramePacket_EmbossReservedAnonymousField2<S::Sliced<'_>, emboss_runtime::UncheckedState> {
1831        unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(self.storage.slice(0, self.storage.len())) }
1832    }
1833    pub fn packet_sequence_number(&mut self) -> emboss_runtime::BitUInt<16, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1834        let len = (2) as usize;
1835        let storage = self.storage.slice_mut(0, len);
1836        emboss_runtime::BitUInt::<16, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1837    }
1838    pub fn iso_sdu_length(&mut self) -> emboss_runtime::BitUInt<12, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
1839        let len = (4) as usize;
1840        let storage = self.storage.slice_mut(0, len);
1841        emboss_runtime::BitUInt::<12, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
1842    }
1843    pub fn packet_status_flag(&mut self) -> emboss_runtime::EnumViewMut<IsoDataPacketStatus, emboss_runtime::BitUInt<2, 30, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
1844        let len = (4) as usize;
1845        let storage = self.storage.slice_mut(0, len);
1846        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
1847    }
1848
1849}
1850
1851impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for IsoDataFramePacket_EmbossReservedAnonymousField2Mut<S> {
1852    type Writer = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState>;
1853    fn into_writer(self) -> Self::Writer {
1854        IsoDataFramePacket_EmbossReservedAnonymousField2Writer::new(self.storage)
1855    }
1856}
1857
1858pub struct IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1859    storage: S,
1860    _marker: core::marker::PhantomData<ST>,
1861}
1862
1863impl<S: emboss_runtime::MutStorage> IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
1864    pub fn new(storage: S) -> Self {
1865        Self {
1866            storage,
1867            _marker: core::marker::PhantomData,
1868        }
1869    }
1870}
1871
1872impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, ST> {
1873    /**
1874     * Constructs a writer in a specific typestate.
1875     *
1876     * # Safety
1877     *
1878     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
1879     */
1880    pub unsafe fn new_in_state(storage: S) -> Self {
1881        Self {
1882            storage,
1883            _marker: core::marker::PhantomData,
1884        }
1885    }
1886    pub fn into_storage(self) -> S {
1887        self.storage
1888    }
1889    /** Converts the writer into an immutable view in the same typestate. */
1890    pub fn into_view(self) -> IsoDataFramePacket_EmbossReservedAnonymousField2<S, ST> {
1891        unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(self.storage) }
1892    }
1893    /** Borrows the writer as an immutable view in the same typestate. */
1894    pub fn as_view(&self) -> IsoDataFramePacket_EmbossReservedAnonymousField2<S::Sliced<'_>, ST> {
1895        unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(self.storage.slice(0, self.storage.len())) }
1896    }
1897
1898}
1899
1900impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFramePacket_EmbossReservedAnonymousField2<S, ST> {
1901    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1902        let view = self;
1903        core::result::Result::Ok((((32) + 7) / 8) as usize)
1904    }
1905}
1906
1907impl<S: emboss_runtime::MutStorage> emboss_runtime::View for IsoDataFramePacket_EmbossReservedAnonymousField2Mut<S> {
1908    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1909        let view = self.as_view();
1910        <IsoDataFramePacket_EmbossReservedAnonymousField2<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
1911    }
1912}
1913
1914impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, ST> {
1915    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
1916        let view = self.as_view();
1917        <IsoDataFramePacket_EmbossReservedAnonymousField2<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
1918    }
1919}
1920
1921impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
1922    type Completed = IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::CompleteState>;
1923    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1924        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1925        if self.storage.len() < required_size {
1926            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1927        }
1928        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(self.storage) })
1929    }
1930}
1931
1932impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
1933    type Completed = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::CompleteState>;
1934    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
1935        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
1936        if self.storage.len() < required_size {
1937            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
1938        }
1939        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2Writer::new_in_state(self.storage) })
1940    }
1941}
1942
1943impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
1944    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
1945    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1946        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1947        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(completed.into_storage()) })
1948    }
1949}
1950
1951impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::CompleteState> {
1952    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
1953    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1954        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2::new_in_state(self.into_storage()) })
1955    }
1956}
1957
1958impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::OkState> {
1959    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
1960    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1961        core::result::Result::Ok(self)
1962    }
1963}
1964
1965impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
1966    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
1967    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1968        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
1969        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2Writer::new_in_state(completed.into_storage()) })
1970    }
1971}
1972
1973impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::CompleteState> {
1974    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
1975    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1976        core::result::Result::Ok(unsafe { IsoDataFramePacket_EmbossReservedAnonymousField2Writer::new_in_state(self.into_storage()) })
1977    }
1978}
1979
1980impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState> {
1981    type Ok = IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
1982    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
1983        core::result::Result::Ok(self)
1984    }
1985}
1986
1987pub mod iso_data_frame_packet_emboss_reserved_anonymous_field2 {
1988    pub type View<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFramePacket_EmbossReservedAnonymousField2<S, ST>;
1989    pub type ViewMut<S> = super::IsoDataFramePacket_EmbossReservedAnonymousField2Mut<S>;
1990    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFramePacket_EmbossReservedAnonymousField2Writer<S, ST>;
1991
1992    pub const MIN_SIZE_IN_BYTES: usize = 4;
1993    pub const MAX_SIZE_IN_BYTES: usize = 4;
1994    pub const SIZE_IN_BYTES: usize = 4;
1995}pub struct IsoDataFramePacket<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
1996    storage: S,
1997    _marker: core::marker::PhantomData<ST>,
1998}
1999
2000impl<S: emboss_runtime::Storage> IsoDataFramePacket<S, emboss_runtime::UncheckedState> {
2001    pub fn new(storage: S) -> Self {
2002        Self {
2003            storage,
2004            _marker: core::marker::PhantomData,
2005        }
2006    }
2007}
2008
2009impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for IsoDataFramePacket<S, ST> {
2010    fn clone(&self) -> Self {
2011        Self {
2012            storage: self.storage.clone(),
2013            _marker: core::marker::PhantomData,
2014        }
2015    }
2016}
2017
2018impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> IsoDataFramePacket<S, ST> {
2019    /**
2020     * Constructs a view in a specific typestate.
2021     *
2022     * # Safety
2023     *
2024     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2025     */
2026    pub unsafe fn new_in_state(storage: S) -> Self {
2027        Self {
2028            storage,
2029            _marker: core::marker::PhantomData,
2030        }
2031    }
2032    pub fn into_storage(self) -> S {
2033        self.storage
2034    }
2035    pub fn hdr_size(&self) -> emboss_runtime::VirtualField<u64> {
2036        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2037        core::result::Result::Ok( (4) as u64 )
2038    })();
2039        emboss_runtime::VirtualField::new(value)
2040    }
2041    pub fn header(&self) -> IsoDataFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2042        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2043            let offset = (0) as usize;
2044            let len = (({ let val = self.hdr_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2045) as usize;
2046            core::result::Result::Ok((offset, len))
2047        })().unwrap_or((usize::MAX, 0));
2048        let storage = self.storage.slice(offset, len);
2049        unsafe { IsoDataFrameHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
2050    }
2051    pub fn ts_size(&self) -> emboss_runtime::VirtualField<u64> {
2052        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2053        core::result::Result::Ok( ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = self.header().ts_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2054), (1) as u64)
2055 { 4 } else { 0 })
2056
2057) as u64 )
2058    })();
2059        emboss_runtime::VirtualField::new(value)
2060    }
2061    pub fn sdu_hdr_offset(&self) -> emboss_runtime::VirtualField<u64> {
2062        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2063        core::result::Result::Ok( (( (({ let val = self.hdr_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2064) as i64 + (({ let val = self.ts_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2065) as i64 )
2066) as u64 )
2067    })();
2068        emboss_runtime::VirtualField::new(value)
2069    }
2070
2071}
2072
2073pub struct IsoDataFramePacketMut<S: emboss_runtime::MutStorage> {
2074    storage: S,
2075}
2076
2077impl<S: emboss_runtime::MutStorage> IsoDataFramePacketMut<S> {
2078    pub fn new(storage: S) -> Self {
2079        Self {
2080            storage,
2081        }
2082    }
2083    pub fn into_writer(self) -> IsoDataFramePacketWriter<S, emboss_runtime::UncheckedState> {
2084        IsoDataFramePacketWriter::new(self.storage)
2085    }
2086    /** Borrows the mutable view as an immutable view in UncheckedState. */
2087    pub fn as_view(&self) -> IsoDataFramePacket<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2088        unsafe { IsoDataFramePacket::new_in_state(self.storage.slice(0, self.storage.len())) }
2089    }
2090    pub fn hdr_size(&mut self) -> emboss_runtime::VirtualField<u64> {
2091        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2092        core::result::Result::Ok( (4) as u64 )
2093    })();
2094        emboss_runtime::VirtualField::new(value)
2095    }
2096    pub fn header(&mut self) -> IsoDataFrameHeaderMut<S::SlicedMut<'_>> {
2097        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2098            let offset = (0) as usize;
2099            let len = (({ let val = self.hdr_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2100) as usize;
2101            core::result::Result::Ok((offset, len))
2102        })().unwrap_or((usize::MAX, 0));
2103        let storage = self.storage.slice_mut(offset, len);
2104        IsoDataFrameHeaderMut::<S::SlicedMut<'_>>::new(storage)
2105    }
2106    pub fn ts_size(&mut self) -> emboss_runtime::VirtualField<u64> {
2107        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2108        core::result::Result::Ok( ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = self.header().ts_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2109), (1) as u64)
2110 { 4 } else { 0 })
2111
2112) as u64 )
2113    })();
2114        emboss_runtime::VirtualField::new(value)
2115    }
2116    pub fn sdu_hdr_offset(&mut self) -> emboss_runtime::VirtualField<u64> {
2117        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2118        core::result::Result::Ok( (( (({ let val = self.hdr_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2119) as i64 + (({ let val = self.ts_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2120) as i64 )
2121) as u64 )
2122    })();
2123        emboss_runtime::VirtualField::new(value)
2124    }
2125
2126}
2127
2128impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for IsoDataFramePacketMut<S> {
2129    type Writer = IsoDataFramePacketWriter<S, emboss_runtime::UncheckedState>;
2130    fn into_writer(self) -> Self::Writer {
2131        IsoDataFramePacketWriter::new(self.storage)
2132    }
2133}
2134
2135pub struct IsoDataFramePacketWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2136    storage: S,
2137    _marker: core::marker::PhantomData<ST>,
2138}
2139
2140impl<S: emboss_runtime::MutStorage> IsoDataFramePacketWriter<S, emboss_runtime::UncheckedState> {
2141    pub fn new(storage: S) -> Self {
2142        Self {
2143            storage,
2144            _marker: core::marker::PhantomData,
2145        }
2146    }
2147}
2148
2149impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> IsoDataFramePacketWriter<S, ST> {
2150    /**
2151     * Constructs a writer in a specific typestate.
2152     *
2153     * # Safety
2154     *
2155     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2156     */
2157    pub unsafe fn new_in_state(storage: S) -> Self {
2158        Self {
2159            storage,
2160            _marker: core::marker::PhantomData,
2161        }
2162    }
2163    pub fn into_storage(self) -> S {
2164        self.storage
2165    }
2166    /** Converts the writer into an immutable view in the same typestate. */
2167    pub fn into_view(self) -> IsoDataFramePacket<S, ST> {
2168        unsafe { IsoDataFramePacket::new_in_state(self.storage) }
2169    }
2170    /** Borrows the writer as an immutable view in the same typestate. */
2171    pub fn as_view(&self) -> IsoDataFramePacket<S::Sliced<'_>, ST> {
2172        unsafe { IsoDataFramePacket::new_in_state(self.storage.slice(0, self.storage.len())) }
2173    }
2174
2175}
2176
2177impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFramePacket<S, ST> {
2178    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2179        let view = self;
2180        core::result::Result::Ok((0) as usize)
2181    }
2182}
2183
2184impl<S: emboss_runtime::MutStorage> emboss_runtime::View for IsoDataFramePacketMut<S> {
2185    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2186        let view = self.as_view();
2187        <IsoDataFramePacket<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2188    }
2189}
2190
2191impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for IsoDataFramePacketWriter<S, ST> {
2192    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2193        let view = self.as_view();
2194        <IsoDataFramePacket<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2195    }
2196}
2197
2198impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for IsoDataFramePacket<S, emboss_runtime::UncheckedState> {
2199    type Completed = IsoDataFramePacket<S, emboss_runtime::CompleteState>;
2200    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2201        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2202        if self.storage.len() < required_size {
2203            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2204        }
2205        core::result::Result::Ok(unsafe { IsoDataFramePacket::new_in_state(self.storage) })
2206    }
2207}
2208
2209impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for IsoDataFramePacketWriter<S, emboss_runtime::UncheckedState> {
2210    type Completed = IsoDataFramePacketWriter<S, emboss_runtime::CompleteState>;
2211    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2212        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2213        if self.storage.len() < required_size {
2214            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2215        }
2216        core::result::Result::Ok(unsafe { IsoDataFramePacketWriter::new_in_state(self.storage) })
2217    }
2218}
2219
2220impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket<S, emboss_runtime::UncheckedState> {
2221    type Ok = IsoDataFramePacket<S, emboss_runtime::OkState>;
2222    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2223        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2224        core::result::Result::Ok(unsafe { IsoDataFramePacket::new_in_state(completed.into_storage()) })
2225    }
2226}
2227
2228impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket<S, emboss_runtime::CompleteState> {
2229    type Ok = IsoDataFramePacket<S, emboss_runtime::OkState>;
2230    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2231        core::result::Result::Ok(unsafe { IsoDataFramePacket::new_in_state(self.into_storage()) })
2232    }
2233}
2234
2235impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for IsoDataFramePacket<S, emboss_runtime::OkState> {
2236    type Ok = IsoDataFramePacket<S, emboss_runtime::OkState>;
2237    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2238        core::result::Result::Ok(self)
2239    }
2240}
2241
2242impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacketWriter<S, emboss_runtime::UncheckedState> {
2243    type Ok = IsoDataFramePacketWriter<S, emboss_runtime::OkState>;
2244    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2245        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2246        core::result::Result::Ok(unsafe { IsoDataFramePacketWriter::new_in_state(completed.into_storage()) })
2247    }
2248}
2249
2250impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacketWriter<S, emboss_runtime::CompleteState> {
2251    type Ok = IsoDataFramePacketWriter<S, emboss_runtime::OkState>;
2252    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2253        core::result::Result::Ok(unsafe { IsoDataFramePacketWriter::new_in_state(self.into_storage()) })
2254    }
2255}
2256
2257impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for IsoDataFramePacketWriter<S, emboss_runtime::OkState> {
2258    type Ok = IsoDataFramePacketWriter<S, emboss_runtime::OkState>;
2259    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2260        core::result::Result::Ok(self)
2261    }
2262}
2263
2264pub mod iso_data_frame_packet {
2265    pub type View<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFramePacket<S, ST>;
2266    pub type ViewMut<S> = super::IsoDataFramePacketMut<S>;
2267    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::IsoDataFramePacketWriter<S, ST>;
2268
2269    pub const MIN_SIZE_IN_BYTES: usize = 4;
2270    pub const MAX_SIZE_IN_BYTES: usize = 16395;
2271}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
2272#[repr(u64)]
2273pub enum ScoDataPacketStatus {
2274    CORRECTLY_RECEIVED_DATA = 0,
2275    POSSIBLY_INVALID_DATA = 1,
2276    NO_DATA_RECEIVE = 2,
2277    DATA_PARTIALLY_LOST = 3,
2278
2279}
2280
2281impl core::convert::From<ScoDataPacketStatus> for u8 { fn from(val: ScoDataPacketStatus) -> Self { val as u8 } }
2282impl core::convert::From<ScoDataPacketStatus> for u16 { fn from(val: ScoDataPacketStatus) -> Self { val as u16 } }
2283impl core::convert::From<ScoDataPacketStatus> for u32 { fn from(val: ScoDataPacketStatus) -> Self { val as u32 } }
2284impl core::convert::From<ScoDataPacketStatus> for u64 { fn from(val: ScoDataPacketStatus) -> Self { val as u64 } }
2285impl core::convert::From<ScoDataPacketStatus> for i8 { fn from(val: ScoDataPacketStatus) -> Self { val as i8 } }
2286impl core::convert::From<ScoDataPacketStatus> for i16 { fn from(val: ScoDataPacketStatus) -> Self { val as i16 } }
2287impl core::convert::From<ScoDataPacketStatus> for i32 { fn from(val: ScoDataPacketStatus) -> Self { val as i32 } }
2288impl core::convert::From<ScoDataPacketStatus> for i64 { fn from(val: ScoDataPacketStatus) -> Self { val as i64 } }
2289
2290impl emboss_runtime::SafeCmp<ScoDataPacketStatus> for ScoDataPacketStatus {
2291    fn safe_eq(&self, other: Self) -> bool { *self == other }
2292    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
2293}
2294
2295impl emboss_runtime::SafeCmp<u64> for ScoDataPacketStatus {
2296    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
2297    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
2298}
2299
2300impl emboss_runtime::SafeCmp<i64> for ScoDataPacketStatus {
2301    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
2302    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
2303}
2304
2305impl emboss_runtime::SafeCmp<i32> for ScoDataPacketStatus {
2306    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
2307    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
2308}
2309
2310impl emboss_runtime::SafeCmp<u32> for ScoDataPacketStatus {
2311    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
2312    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
2313}
2314
2315impl emboss_runtime::SafeCmp<ScoDataPacketStatus> for u64 {
2316    fn safe_eq(&self, other: ScoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
2317    fn safe_less(&self, other: ScoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
2318}
2319
2320impl emboss_runtime::SafeCmp<ScoDataPacketStatus> for i64 {
2321    fn safe_eq(&self, other: ScoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
2322    fn safe_less(&self, other: ScoDataPacketStatus) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
2323}
2324
2325impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for ScoDataPacketStatus {
2326    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
2327        let v_raw: u64 = val.into();
2328        match v_raw {
2329            0 => Ok(ScoDataPacketStatus::CORRECTLY_RECEIVED_DATA),
2330            1 => Ok(ScoDataPacketStatus::POSSIBLY_INVALID_DATA),
2331            2 => Ok(ScoDataPacketStatus::NO_DATA_RECEIVE),
2332            3 => Ok(ScoDataPacketStatus::DATA_PARTIALLY_LOST),
2333
2334            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
2335        }
2336    }
2337}
2338
2339impl ScoDataPacketStatus {
2340
2341}
2342pub struct ScoDataHeader_EmbossReservedAnonymousField1<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2343    storage: S,
2344    _marker: core::marker::PhantomData<ST>,
2345}
2346
2347impl<S: emboss_runtime::Storage> ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
2348    pub fn new(storage: S) -> Self {
2349        Self {
2350            storage,
2351            _marker: core::marker::PhantomData,
2352        }
2353    }
2354}
2355
2356impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for ScoDataHeader_EmbossReservedAnonymousField1<S, ST> {
2357    fn clone(&self) -> Self {
2358        Self {
2359            storage: self.storage.clone(),
2360            _marker: core::marker::PhantomData,
2361        }
2362    }
2363}
2364
2365impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> ScoDataHeader_EmbossReservedAnonymousField1<S, ST> {
2366    /**
2367     * Constructs a view in a specific typestate.
2368     *
2369     * # Safety
2370     *
2371     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2372     */
2373    pub unsafe fn new_in_state(storage: S) -> Self {
2374        Self {
2375            storage,
2376            _marker: core::marker::PhantomData,
2377        }
2378    }
2379    pub fn into_storage(self) -> S {
2380        self.storage
2381    }
2382    pub fn connection_handle(&self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
2383        let len = (2) as usize; // Total struct size in bytes
2384        let storage = self.storage.slice(0, len);
2385        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
2386    }
2387    pub fn packet_status_flag(&self) -> emboss_runtime::EnumView<ScoDataPacketStatus, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::Sliced<'_>, ST>> {
2388        let len = (2) as usize;
2389        let storage = self.storage.slice(0, len);
2390        emboss_runtime::EnumView::new(emboss_runtime::BitUInt::new(storage))
2391    }
2392    pub fn data_total_length(&self) -> emboss_runtime::BitUInt<8, 16, emboss_runtime::Null, S::Sliced<'_>, ST> {
2393        let len = (3) as usize; // Total struct size in bytes
2394        let storage = self.storage.slice(0, len);
2395        emboss_runtime::BitUInt::<8, 16, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
2396    }
2397
2398}
2399
2400pub struct ScoDataHeader_EmbossReservedAnonymousField1Mut<S: emboss_runtime::MutStorage> {
2401    storage: S,
2402}
2403
2404impl<S: emboss_runtime::MutStorage> ScoDataHeader_EmbossReservedAnonymousField1Mut<S> {
2405    pub fn new(storage: S) -> Self {
2406        Self {
2407            storage,
2408        }
2409    }
2410    pub fn into_writer(self) -> ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
2411        ScoDataHeader_EmbossReservedAnonymousField1Writer::new(self.storage)
2412    }
2413    /** Borrows the mutable view as an immutable view in UncheckedState. */
2414    pub fn as_view(&self) -> ScoDataHeader_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2415        unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(self.storage.slice(0, self.storage.len())) }
2416    }
2417    pub fn connection_handle(&mut self) -> emboss_runtime::BitUInt<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2418        let len = (2) as usize;
2419        let storage = self.storage.slice_mut(0, len);
2420        emboss_runtime::BitUInt::<12, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2421    }
2422    pub fn packet_status_flag(&mut self) -> emboss_runtime::EnumViewMut<ScoDataPacketStatus, emboss_runtime::BitUInt<2, 12, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
2423        let len = (2) as usize;
2424        let storage = self.storage.slice_mut(0, len);
2425        emboss_runtime::EnumViewMut::new(emboss_runtime::BitUInt::new(storage))
2426    }
2427    pub fn data_total_length(&mut self) -> emboss_runtime::BitUInt<8, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
2428        let len = (3) as usize;
2429        let storage = self.storage.slice_mut(0, len);
2430        emboss_runtime::BitUInt::<8, 16, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
2431    }
2432
2433}
2434
2435impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for ScoDataHeader_EmbossReservedAnonymousField1Mut<S> {
2436    type Writer = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState>;
2437    fn into_writer(self) -> Self::Writer {
2438        ScoDataHeader_EmbossReservedAnonymousField1Writer::new(self.storage)
2439    }
2440}
2441
2442pub struct ScoDataHeader_EmbossReservedAnonymousField1Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2443    storage: S,
2444    _marker: core::marker::PhantomData<ST>,
2445}
2446
2447impl<S: emboss_runtime::MutStorage> ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
2448    pub fn new(storage: S) -> Self {
2449        Self {
2450            storage,
2451            _marker: core::marker::PhantomData,
2452        }
2453    }
2454}
2455
2456impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> ScoDataHeader_EmbossReservedAnonymousField1Writer<S, ST> {
2457    /**
2458     * Constructs a writer in a specific typestate.
2459     *
2460     * # Safety
2461     *
2462     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2463     */
2464    pub unsafe fn new_in_state(storage: S) -> Self {
2465        Self {
2466            storage,
2467            _marker: core::marker::PhantomData,
2468        }
2469    }
2470    pub fn into_storage(self) -> S {
2471        self.storage
2472    }
2473    /** Converts the writer into an immutable view in the same typestate. */
2474    pub fn into_view(self) -> ScoDataHeader_EmbossReservedAnonymousField1<S, ST> {
2475        unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(self.storage) }
2476    }
2477    /** Borrows the writer as an immutable view in the same typestate. */
2478    pub fn as_view(&self) -> ScoDataHeader_EmbossReservedAnonymousField1<S::Sliced<'_>, ST> {
2479        unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(self.storage.slice(0, self.storage.len())) }
2480    }
2481
2482}
2483
2484impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for ScoDataHeader_EmbossReservedAnonymousField1<S, ST> {
2485    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2486        let view = self;
2487        core::result::Result::Ok((((24) + 7) / 8) as usize)
2488    }
2489}
2490
2491impl<S: emboss_runtime::MutStorage> emboss_runtime::View for ScoDataHeader_EmbossReservedAnonymousField1Mut<S> {
2492    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2493        let view = self.as_view();
2494        <ScoDataHeader_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2495    }
2496}
2497
2498impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, ST> {
2499    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2500        let view = self.as_view();
2501        <ScoDataHeader_EmbossReservedAnonymousField1<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2502    }
2503}
2504
2505impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
2506    type Completed = ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::CompleteState>;
2507    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2508        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2509        if self.storage.len() < required_size {
2510            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2511        }
2512        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(self.storage) })
2513    }
2514}
2515
2516impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
2517    type Completed = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::CompleteState>;
2518    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2519        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2520        if self.storage.len() < required_size {
2521            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2522        }
2523        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1Writer::new_in_state(self.storage) })
2524    }
2525}
2526
2527impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
2528    type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
2529    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2530        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2531        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(completed.into_storage()) })
2532    }
2533}
2534
2535impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::CompleteState> {
2536    type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
2537    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2538        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1::new_in_state(self.into_storage()) })
2539    }
2540}
2541
2542impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::OkState> {
2543    type Ok = ScoDataHeader_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
2544    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2545        core::result::Result::Ok(self)
2546    }
2547}
2548
2549impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
2550    type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
2551    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2552        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2553        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1Writer::new_in_state(completed.into_storage()) })
2554    }
2555}
2556
2557impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::CompleteState> {
2558    type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
2559    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2560        core::result::Result::Ok(unsafe { ScoDataHeader_EmbossReservedAnonymousField1Writer::new_in_state(self.into_storage()) })
2561    }
2562}
2563
2564impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState> {
2565    type Ok = ScoDataHeader_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
2566    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2567        core::result::Result::Ok(self)
2568    }
2569}
2570
2571pub mod sco_data_header_emboss_reserved_anonymous_field1 {
2572    pub type View<S, ST = emboss_runtime::UncheckedState> = super::ScoDataHeader_EmbossReservedAnonymousField1<S, ST>;
2573    pub type ViewMut<S> = super::ScoDataHeader_EmbossReservedAnonymousField1Mut<S>;
2574    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::ScoDataHeader_EmbossReservedAnonymousField1Writer<S, ST>;
2575
2576    pub const MIN_SIZE_IN_BYTES: usize = 3;
2577    pub const MAX_SIZE_IN_BYTES: usize = 3;
2578    pub const SIZE_IN_BYTES: usize = 3;
2579}pub struct ScoDataHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2580    storage: S,
2581    _marker: core::marker::PhantomData<ST>,
2582}
2583
2584impl<S: emboss_runtime::Storage> ScoDataHeader<S, emboss_runtime::UncheckedState> {
2585    pub fn new(storage: S) -> Self {
2586        Self {
2587            storage,
2588            _marker: core::marker::PhantomData,
2589        }
2590    }
2591}
2592
2593impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for ScoDataHeader<S, ST> {
2594    fn clone(&self) -> Self {
2595        Self {
2596            storage: self.storage.clone(),
2597            _marker: core::marker::PhantomData,
2598        }
2599    }
2600}
2601
2602impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> ScoDataHeader<S, ST> {
2603    /**
2604     * Constructs a view in a specific typestate.
2605     *
2606     * # Safety
2607     *
2608     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2609     */
2610    pub unsafe fn new_in_state(storage: S) -> Self {
2611        Self {
2612            storage,
2613            _marker: core::marker::PhantomData,
2614        }
2615    }
2616    pub fn into_storage(self) -> S {
2617        self.storage
2618    }
2619    pub fn emboss_reserved_anonymous_field_1(&self) -> ScoDataHeader_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2620        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2621            let offset = (0) as usize;
2622            let len = (3) as usize;
2623            core::result::Result::Ok((offset, len))
2624        })().unwrap_or((usize::MAX, 0));
2625        let storage = self.storage.slice(offset, len);
2626        unsafe { ScoDataHeader_EmbossReservedAnonymousField1::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
2627    }
2628    pub fn connection_handle(&self) -> emboss_runtime::VirtualField<u64> {
2629        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2630        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().connection_handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2631) as u64 )
2632    })();
2633        emboss_runtime::VirtualField::new(value)
2634    }
2635    pub fn packet_status_flag(&self) -> emboss_runtime::VirtualField<ScoDataPacketStatus> {
2636        let value = (|| -> core::result::Result<ScoDataPacketStatus, emboss_runtime::Error> {
2637        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().packet_status_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2638) as ScoDataPacketStatus )
2639    })();
2640        emboss_runtime::VirtualField::new(value)
2641    }
2642    pub fn data_total_length(&self) -> emboss_runtime::VirtualField<u64> {
2643        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2644        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2645) as u64 )
2646    })();
2647        emboss_runtime::VirtualField::new(value)
2648    }
2649
2650}
2651
2652pub struct ScoDataHeaderMut<S: emboss_runtime::MutStorage> {
2653    storage: S,
2654}
2655
2656impl<S: emboss_runtime::MutStorage> ScoDataHeaderMut<S> {
2657    pub fn new(storage: S) -> Self {
2658        Self {
2659            storage,
2660        }
2661    }
2662    pub fn into_writer(self) -> ScoDataHeaderWriter<S, emboss_runtime::UncheckedState> {
2663        ScoDataHeaderWriter::new(self.storage)
2664    }
2665    /** Borrows the mutable view as an immutable view in UncheckedState. */
2666    pub fn as_view(&self) -> ScoDataHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
2667        unsafe { ScoDataHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
2668    }
2669    pub fn emboss_reserved_anonymous_field_1(&mut self) -> ScoDataHeader_EmbossReservedAnonymousField1Mut<S::SlicedMut<'_>> {
2670        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
2671            let offset = (0) as usize;
2672            let len = (3) as usize;
2673            core::result::Result::Ok((offset, len))
2674        })().unwrap_or((usize::MAX, 0));
2675        let storage = self.storage.slice_mut(offset, len);
2676        ScoDataHeader_EmbossReservedAnonymousField1Mut::<S::SlicedMut<'_>>::new(storage)
2677    }
2678    pub fn connection_handle(&mut self) -> emboss_runtime::VirtualField<u64> {
2679        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2680        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().connection_handle().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2681) as u64 )
2682    })();
2683        emboss_runtime::VirtualField::new(value)
2684    }
2685    pub fn packet_status_flag(&mut self) -> emboss_runtime::VirtualField<ScoDataPacketStatus> {
2686        let value = (|| -> core::result::Result<ScoDataPacketStatus, emboss_runtime::Error> {
2687        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().packet_status_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2688) as ScoDataPacketStatus )
2689    })();
2690        emboss_runtime::VirtualField::new(value)
2691    }
2692    pub fn data_total_length(&mut self) -> emboss_runtime::VirtualField<u64> {
2693        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
2694        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().data_total_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
2695) as u64 )
2696    })();
2697        emboss_runtime::VirtualField::new(value)
2698    }
2699
2700}
2701
2702impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for ScoDataHeaderMut<S> {
2703    type Writer = ScoDataHeaderWriter<S, emboss_runtime::UncheckedState>;
2704    fn into_writer(self) -> Self::Writer {
2705        ScoDataHeaderWriter::new(self.storage)
2706    }
2707}
2708
2709pub struct ScoDataHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
2710    storage: S,
2711    _marker: core::marker::PhantomData<ST>,
2712}
2713
2714impl<S: emboss_runtime::MutStorage> ScoDataHeaderWriter<S, emboss_runtime::UncheckedState> {
2715    pub fn new(storage: S) -> Self {
2716        Self {
2717            storage,
2718            _marker: core::marker::PhantomData,
2719        }
2720    }
2721}
2722
2723impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> ScoDataHeaderWriter<S, ST> {
2724    /**
2725     * Constructs a writer in a specific typestate.
2726     *
2727     * # Safety
2728     *
2729     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
2730     */
2731    pub unsafe fn new_in_state(storage: S) -> Self {
2732        Self {
2733            storage,
2734            _marker: core::marker::PhantomData,
2735        }
2736    }
2737    pub fn into_storage(self) -> S {
2738        self.storage
2739    }
2740    /** Converts the writer into an immutable view in the same typestate. */
2741    pub fn into_view(self) -> ScoDataHeader<S, ST> {
2742        unsafe { ScoDataHeader::new_in_state(self.storage) }
2743    }
2744    /** Borrows the writer as an immutable view in the same typestate. */
2745    pub fn as_view(&self) -> ScoDataHeader<S::Sliced<'_>, ST> {
2746        unsafe { ScoDataHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
2747    }
2748
2749}
2750
2751impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for ScoDataHeader<S, ST> {
2752    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2753        let view = self;
2754        core::result::Result::Ok((3) as usize)
2755    }
2756}
2757
2758impl<S: emboss_runtime::MutStorage> emboss_runtime::View for ScoDataHeaderMut<S> {
2759    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2760        let view = self.as_view();
2761        <ScoDataHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
2762    }
2763}
2764
2765impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for ScoDataHeaderWriter<S, ST> {
2766    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
2767        let view = self.as_view();
2768        <ScoDataHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
2769    }
2770}
2771
2772impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for ScoDataHeader<S, emboss_runtime::UncheckedState> {
2773    type Completed = ScoDataHeader<S, emboss_runtime::CompleteState>;
2774    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2775        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2776        if self.storage.len() < required_size {
2777            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2778        }
2779        core::result::Result::Ok(unsafe { ScoDataHeader::new_in_state(self.storage) })
2780    }
2781}
2782
2783impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for ScoDataHeaderWriter<S, emboss_runtime::UncheckedState> {
2784    type Completed = ScoDataHeaderWriter<S, emboss_runtime::CompleteState>;
2785    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
2786        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
2787        if self.storage.len() < required_size {
2788            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
2789        }
2790        core::result::Result::Ok(unsafe { ScoDataHeaderWriter::new_in_state(self.storage) })
2791    }
2792}
2793
2794impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader<S, emboss_runtime::UncheckedState> {
2795    type Ok = ScoDataHeader<S, emboss_runtime::OkState>;
2796    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2797        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2798        core::result::Result::Ok(unsafe { ScoDataHeader::new_in_state(completed.into_storage()) })
2799    }
2800}
2801
2802impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader<S, emboss_runtime::CompleteState> {
2803    type Ok = ScoDataHeader<S, emboss_runtime::OkState>;
2804    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2805        core::result::Result::Ok(unsafe { ScoDataHeader::new_in_state(self.into_storage()) })
2806    }
2807}
2808
2809impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for ScoDataHeader<S, emboss_runtime::OkState> {
2810    type Ok = ScoDataHeader<S, emboss_runtime::OkState>;
2811    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2812        core::result::Result::Ok(self)
2813    }
2814}
2815
2816impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeaderWriter<S, emboss_runtime::UncheckedState> {
2817    type Ok = ScoDataHeaderWriter<S, emboss_runtime::OkState>;
2818    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2819        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
2820        core::result::Result::Ok(unsafe { ScoDataHeaderWriter::new_in_state(completed.into_storage()) })
2821    }
2822}
2823
2824impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeaderWriter<S, emboss_runtime::CompleteState> {
2825    type Ok = ScoDataHeaderWriter<S, emboss_runtime::OkState>;
2826    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2827        core::result::Result::Ok(unsafe { ScoDataHeaderWriter::new_in_state(self.into_storage()) })
2828    }
2829}
2830
2831impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for ScoDataHeaderWriter<S, emboss_runtime::OkState> {
2832    type Ok = ScoDataHeaderWriter<S, emboss_runtime::OkState>;
2833    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
2834        core::result::Result::Ok(self)
2835    }
2836}
2837
2838pub mod sco_data_header {
2839    pub type View<S, ST = emboss_runtime::UncheckedState> = super::ScoDataHeader<S, ST>;
2840    pub type ViewMut<S> = super::ScoDataHeaderMut<S>;
2841    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::ScoDataHeaderWriter<S, ST>;
2842
2843    pub const MIN_SIZE_IN_BYTES: usize = 3;
2844    pub const MAX_SIZE_IN_BYTES: usize = 3;
2845    pub const SIZE_IN_BYTES: usize = 3;
2846}
pw_bluetooth_hci_data_emb/hci_data.rs

pw_bluetooth_hci_data_emb/
hci_data.rs
