fidl_next_codec/wire/
union.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use core::mem::MaybeUninit;
6
7use munge::munge;
8
9use crate::decoder::InternalHandleDecoder;
10use crate::encoder::InternalHandleEncoder;
11use crate::{
12    Decode, DecodeError, Decoder, Encode, EncodeError, Encoder, Slot, WireEnvelope, WireU64,
13    ZeroPadding,
14};
15
16/// A raw FIDL union
17#[repr(C)]
18pub struct RawWireUnion {
19    ordinal: WireU64,
20    envelope: WireEnvelope,
21}
22
23unsafe impl ZeroPadding for RawWireUnion {
24    #[inline]
25    fn zero_padding(_: &mut MaybeUninit<Self>) {
26        // Wire unions have no padding
27    }
28}
29
30impl RawWireUnion {
31    /// Encodes that a union is absent in a slot.
32    #[inline]
33    pub fn encode_absent(out: &mut MaybeUninit<Self>) {
34        munge!(let Self { ordinal, envelope } = out);
35
36        ordinal.write(WireU64(0));
37        WireEnvelope::encode_zero(envelope);
38    }
39
40    /// Encodes a `'static` value and ordinal in a slot.
41    #[inline]
42    pub fn encode_as_static<E: InternalHandleEncoder + ?Sized, T: Encode<E>>(
43        value: &mut T,
44        ord: u64,
45        encoder: &mut E,
46        out: &mut MaybeUninit<Self>,
47    ) -> Result<(), EncodeError> {
48        munge!(let Self { ordinal, envelope } = out);
49
50        ordinal.write(WireU64(ord));
51        WireEnvelope::encode_value_static(value, encoder, envelope)
52    }
53
54    /// Encodes a value and ordinal in a slot.
55    #[inline]
56    pub fn encode_as<E: Encoder + ?Sized, T: Encode<E>>(
57        value: &mut T,
58        ord: u64,
59        encoder: &mut E,
60        out: &mut MaybeUninit<Self>,
61    ) -> Result<(), EncodeError> {
62        munge!(let Self { ordinal, envelope } = out);
63
64        ordinal.write(WireU64(ord));
65        WireEnvelope::encode_value(value, encoder, envelope)
66    }
67
68    /// Returns the ordinal of the encoded value.
69    #[inline]
70    pub fn encoded_ordinal(slot: Slot<'_, Self>) -> u64 {
71        munge!(let Self { ordinal, envelope: _ } = slot);
72        **ordinal
73    }
74
75    /// Decodes an absent union from a slot.
76    #[inline]
77    pub fn decode_absent(slot: Slot<'_, Self>) -> Result<(), DecodeError> {
78        munge!(let Self { ordinal: _, envelope } = slot);
79        if !WireEnvelope::is_encoded_zero(envelope) {
80            return Err(DecodeError::InvalidUnionEnvelope);
81        }
82        Ok(())
83    }
84
85    /// Decodes an unknown `'static` value from a union.
86    ///
87    /// The handles owned by the unknown value are discarded.
88    #[inline]
89    pub fn decode_unknown_static<D: InternalHandleDecoder + ?Sized>(
90        slot: Slot<'_, Self>,
91        decoder: &mut D,
92    ) -> Result<(), DecodeError> {
93        munge!(let Self { ordinal: _, envelope } = slot);
94        WireEnvelope::decode_unknown_static(envelope, decoder)
95    }
96
97    /// Decodes an unknown value from a union.
98    ///
99    /// The handles owned by the unknown value are discarded.
100    #[inline]
101    pub fn decode_unknown<D: Decoder + ?Sized>(
102        slot: Slot<'_, Self>,
103        decoder: &mut D,
104    ) -> Result<(), DecodeError> {
105        munge!(let Self { ordinal: _, envelope } = slot);
106        WireEnvelope::decode_unknown(envelope, decoder)
107    }
108
109    /// Decodes the typed `'static` value in a union.
110    #[inline]
111    pub fn decode_as_static<D: InternalHandleDecoder + ?Sized, T: Decode<D>>(
112        slot: Slot<'_, Self>,
113        decoder: &mut D,
114    ) -> Result<(), DecodeError> {
115        munge!(let Self { ordinal: _, envelope } = slot);
116        WireEnvelope::decode_as_static::<D, T>(envelope, decoder)
117    }
118
119    /// Decodes the typed value in a union.
120    #[inline]
121    pub fn decode_as<D: Decoder + ?Sized, T: Decode<D>>(
122        slot: Slot<'_, Self>,
123        decoder: &mut D,
124    ) -> Result<(), DecodeError> {
125        munge!(let Self { ordinal: _, envelope } = slot);
126        WireEnvelope::decode_as::<D, T>(envelope, decoder)
127    }
128
129    /// The absent optional union.
130    #[inline]
131    pub fn absent() -> Self {
132        Self { ordinal: WireU64(0), envelope: WireEnvelope::zero() }
133    }
134
135    /// Returns whether the union contains a value.
136    #[inline]
137    pub fn is_some(&self) -> bool {
138        *self.ordinal != 0
139    }
140
141    /// Returns whether the union is empty.
142    #[inline]
143    pub fn is_none(&self) -> bool {
144        !self.is_some()
145    }
146
147    /// Returns the ordinal of the union.
148    #[inline]
149    pub fn ordinal(&self) -> u64 {
150        *self.ordinal
151    }
152
153    /// Gets a reference to the envelope underlying the union.
154    #[inline]
155    pub fn get(&self) -> &WireEnvelope {
156        &self.envelope
157    }
158
159    /// Clones the union, assuming that it contains an inline `T`.
160    ///
161    /// # Safety
162    ///
163    /// The union must have been successfully decoded as a `T`.
164    #[inline]
165    pub unsafe fn clone_unchecked<T: Clone>(&self) -> Self {
166        Self { ordinal: self.ordinal, envelope: unsafe { self.envelope.clone_unchecked::<T>() } }
167    }
168}
fidl_next_codec/wire/union.rs

fidl_next_codec/wire/
union.rs
