Merge "libbinder_rs: Fix broken documentation links" into main am: 5b533d28...

/// Interface stability promise

///

/// An interface can promise to be a stable vendor interface ([`Vintf`]), or

/// makes no stability guarantees ([`Local`]). [`Local`] is

/// An interface can promise to be a stable vendor interface ([`Stability::Vintf`]),

/// or makes no stability guarantees ([`Stability::Local`]). [`Stability::Local`] is

/// currently the default stability.

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default)]

pub enum Stability {

/// via `Binder::new(object)`.

///

/// This is a low-level interface that should normally be automatically

/// generated from AIDL via the [`declare_binder_interface!`] macro. When using

/// the AIDL backend, users need only implement the high-level AIDL-defined

/// generated from AIDL via the [`crate::declare_binder_interface!`] macro.

/// When using the AIDL backend, users need only implement the high-level AIDL-defined

/// interface. The AIDL compiler then generates a container struct that wraps

/// the user-defined service and implements `Remotable`.

pub trait Remotable: Send + Sync {

    /// Note: the returned pointer will not be constant. Calling this method

    /// multiple times for the same type will result in distinct class

    /// pointers. A static getter for this value is implemented in

    /// [`declare_binder_interface!`].

    /// [`crate::declare_binder_interface!`].

    pub fn new<I: InterfaceClassMethods>() -> InterfaceClass {

        let descriptor = CString::new(I::get_descriptor()).unwrap();

        let ptr = unsafe {

    /// and call a closure with the sub-parcel as its parameter.

    /// The closure can keep reading data from the sub-parcel

    /// until it runs out of input data. The closure is responsible

    /// for calling [`ReadableSubParcel::has_more_data`] to check for

    /// for calling `ReadableSubParcel::has_more_data` to check for

    /// more data before every read, at least until Rust generators

    /// are stabilized.

    /// After the closure returns, skip to the end of the current

    /// and call a closure with the sub-parcel as its parameter.

    /// The closure can keep reading data from the sub-parcel

    /// until it runs out of input data. The closure is responsible

    /// for calling [`ReadableSubParcel::has_more_data`] to check for

    /// for calling `ReadableSubParcel::has_more_data` to check for

    /// more data before every read, at least until Rust generators

    /// are stabilized.

    /// After the closure returns, skip to the end of the current

    fn read_from_parcel(&mut self, parcel: &BorrowedParcel<'_>) -> Result<()>;

}

/// A struct whose instances can be written to a [`Parcel`].

/// A struct whose instances can be written to a [`crate::parcel::Parcel`].

// Might be able to hook this up as a serde backend in the future?

pub trait Serialize {

    /// Serialize this instance into the given [`Parcel`].

    /// Serialize this instance into the given [`crate::parcel::Parcel`].

    fn serialize(&self, parcel: &mut BorrowedParcel<'_>) -> Result<()>;

}

/// A struct whose instances can be restored from a [`Parcel`].

/// A struct whose instances can be restored from a [`crate::parcel::Parcel`].

// Might be able to hook this up as a serde backend in the future?

pub trait Deserialize: Sized {

    /// Type for the uninitialized value of this type. Will be either `Self`

    /// Convert an initialized value of type `Self` into `Self::UninitType`.

    fn from_init(value: Self) -> Self::UninitType;

    /// Deserialize an instance from the given [`Parcel`].

    /// Deserialize an instance from the given [`crate::parcel::Parcel`].

    fn deserialize(parcel: &BorrowedParcel<'_>) -> Result<Self>;

    /// Deserialize an instance from the given [`Parcel`] onto the

    /// Deserialize an instance from the given [`crate::parcel::Parcel`] onto the

    /// current object. This operation will overwrite the old value

    /// partially or completely, depending on how much data is available.

    fn deserialize_from(&mut self, parcel: &BorrowedParcel<'_>) -> Result<()> {

/// `Serialize`, `SerializeArray` and `SerializeOption` for

/// structured parcelables. The target type must implement the

/// `Parcelable` trait.

/// ```

#[macro_export]

macro_rules! impl_serialize_for_parcelable {

    ($parcelable:ident) => {

/// Rust wrapper around DeathRecipient objects.

///

/// The cookie in this struct represents an Arc<F> for the owned callback.

/// The cookie in this struct represents an `Arc<F>` for the owned callback.

/// This struct owns a ref-count of it, and so does every binder that we

/// have been linked with.

///

    ///

    /// # Safety

    ///

    /// The `cookie` parameter must be the cookie for an Arc<F> and

    /// The `cookie` parameter must be the cookie for an `Arc<F>` and

    /// the caller must hold a ref-count to it.

    unsafe extern "C" fn binder_died<F>(cookie: *mut c_void)

    where

    ///

    /// # Safety

    ///

    /// The `cookie` parameter must be the cookie for an Arc<F> and

    /// The `cookie` parameter must be the cookie for an `Arc<F>` and

    /// the owner must give up a ref-count to it.

    unsafe extern "C" fn cookie_decr_refcount<F>(cookie: *mut c_void)

    where

    ///

    /// # Safety

    ///

    /// The `cookie` parameter must be the cookie for an Arc<F> and

    /// The `cookie` parameter must be the cookie for an `Arc<F>` and

    /// the owner must handle the created ref-count properly.

    unsafe extern "C" fn cookie_incr_refcount<F>(cookie: *mut c_void)

    where