fidl_fuchsia_time_alarms__common/

fidl_fuchsia_time_alarms__common.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// A unique identifier for an alarm.
///
/// This alias is used to identify alarms within a single `WakeAlarms`
/// connection. It is the client's responsibility to ensure that the IDs are
/// unique for all active alarms.
pub type AlarmId = String;

/// Describes the error codes that can be returned from `WakeAlarms` API calls.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum WakeAlarmsError {
    /// A new failure mode has been observed that has not yet been assigned an
    /// error code.
    ///
    /// This indicates that the API version may need to be updated.
    Unspecified,
    /// The alarm was canceled or rescheduled by the API user.
    Dropped,
    /// The server end encountered an error internal to its code, which should
    /// not ever happen in normal operation. Receiving this error means that the
    /// server end of the connection has a bug that must be fixed.
    Internal,
    /// A parameter provided by the user is incorrect. For example, providing
    /// an empty value for `alarm_id`.
    InvalidArgs,
    /// The driver connection was cut off. The wake alarms service can not
    /// recover.
    DriverConnection,
    /// The driver reported an internal error. This is a driver bug most likely.
    Driver,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `WakeAlarmsError` member.
#[macro_export]
macro_rules! WakeAlarmsErrorUnknown {
    () => {
        _
    };
}

impl WakeAlarmsError {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Unspecified),
            2 => Some(Self::Dropped),
            3 => Some(Self::Internal),
            4 => Some(Self::InvalidArgs),
            5 => Some(Self::DriverConnection),
            6 => Some(Self::Driver),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Unspecified,
            2 => Self::Dropped,
            3 => Self::Internal,
            4 => Self::InvalidArgs,
            5 => Self::DriverConnection,
            6 => Self::Driver,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Unspecified => 1,
            Self::Dropped => 2,
            Self::Internal => 3,
            Self::InvalidArgs => 4,
            Self::DriverConnection => 5,
            Self::Driver => 6,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// A timestamp denoting an instant on the UTC timeline.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct InstantUtc {
    /// `timestamp_utc` is the number of nanoseconds since the start of the Unix
    /// epoch, relative to the UTC timezone.
    ///
    /// Fuchsia FIDL library `zx` does not have a core type that denotes this
    /// (in contrast to say `zx.Time`), so we use a custom type to try and make
    /// it harder to provide a timestamp set on the wrong timeline.
    ///
    /// ## Usage note
    ///
    /// Timestamps that reference the UTC timeline are unusual. This is because
    /// the UTC timeline is actively adjusted to match the external notion of
    /// accurate UTC time, and can change the rate, or can even "jump" both
    /// forwards or backwards. Adjusting the notion of the UTC time manually
    /// can pull in or push out deadlines tied to this timeline.
    ///
    /// This is why it is always recommended to use the UTC timeline only to
    /// denote instants on the UTC timeline, and not use it to measure
    /// durations.
    pub timestamp_utc: i64,
}

impl fidl::Persistable for InstantUtc {}

#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct WakeAlarmsCancelRequest {
    /// The unique identifier of the alarm to cancel.
    ///
    /// The alarm identified by `alarm_id` is canceled, and will no
    /// longer be expected to fire. The respective `SetAndWait` will
    /// return `WakeAlarmsError.DROPPED`.
    ///
    /// A race condition is possible where the alarm fires while
    /// the `Cancel` call is being processed, or even slightly later.
    /// The caller must handle such an event gracefully.
    pub alarm_id: String,
}

impl fidl::Persistable for WakeAlarmsCancelRequest {}

pub mod notifier_ordinals {
    pub const NOTIFY: u64 = 0x23d11b31ba0d67d4;
    pub const NOTIFY_ERROR: u64 = 0x62e915191b0113e9;
}

pub mod wake_alarms_ordinals {
    pub const SET_AND_WAIT: u64 = 0x57ebd075ce4beba;
    pub const CANCEL: u64 = 0x7b23a9760115e55c;
    pub const SET: u64 = 0x1f110857e48fd72c;
    pub const SET_AND_WAIT_UTC: u64 = 0x4ea69d33af584219;
}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for WakeAlarmsError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for WakeAlarmsError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for WakeAlarmsError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WakeAlarmsError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for InstantUtc {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for InstantUtc {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<InstantUtc, D>
        for &InstantUtc
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InstantUtc>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut InstantUtc).write_unaligned((self as *const InstantUtc).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i64, D>>
        fidl::encoding::Encode<InstantUtc, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<InstantUtc>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InstantUtc {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { timestamp_utc: fidl::new_empty!(i64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for WakeAlarmsCancelRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for WakeAlarmsCancelRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<WakeAlarmsCancelRequest, D> for &WakeAlarmsCancelRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WakeAlarmsCancelRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<WakeAlarmsCancelRequest, D>::encode(
                (<fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(
                    &self.alarm_id,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
    > fidl::encoding::Encode<WakeAlarmsCancelRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WakeAlarmsCancelRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for WakeAlarmsCancelRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { alarm_id: fidl::new_empty!(fidl::encoding::BoundedString<128>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<128>,
                D,
                &mut self.alarm_id,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }
}