Struct RSidecar 

pub struct RSidecar;

Marker type for enabling R sidecar accessors in an ExternalPtr struct.

When used with #[derive(ExternalPtr)] and #[r_data], this field acts as a selector that enables R-facing accessors for sibling #[r_data] fields.

Supported Field Types

• Sidecar<T> - a typed value kept in the external pointer’s protection list (not in the struct), so the pointer roots it and saveRDS() writes it; Rust reads and writes it through the accessors the derive generates
• i32, f64, bool, u8 - scalars read with Rf_as* on write and returned as a fresh length-1 vector on read
• Any IntoR + TryFromSexp type - converted on every read and write (e.g., String, Vec<T>)
• Computed - a read-only field computed from the Rust value by a getter function (#[r_data(get = "Self::f")])

Every field but a Sidecar lives in the Rust struct, so a reader always sees the Rust value and a writer either converts into it or gets an error. Those values sit behind the pointer’s address, which saveRDS does not write. Sidecar values travel with the pointer.

Example

use miniextendr_api::externalptr::{RSidecar, Sidecar};

#[derive(ExternalPtr)]
pub struct MyType {
    pub x: i32,

    /// Selector field - enables R wrapper generation
    #[r_data]
    r: RSidecar,

    /// Rooted value - MyType_get_keys() / MyType_set_keys(), and
    /// `MyType::keys(&ptr)` / `MyType::set_keys(&mut ptr, v)` in Rust
    #[r_data]
    pub keys: Sidecar<Vec<i32>>,

    /// Zero-overhead scalar - MyType_get_count() / MyType_set_count()
    #[r_data]
    pub count: i32,

    /// Conversion type - MyType_get_name() / MyType_set_name()
    #[r_data]
    pub name: String,
}

Design Notes

• RSidecar is a ZST (zero-sized type) - no runtime cost
• Only pub #[r_data] fields get R wrapper functions generated
• Multiple RSidecar fields in one struct is a compile error

Trait Implementations

impl Clone for RSidecar

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for RSidecar

impl Debug for RSidecar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RSidecar

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RSidecar

#[doc(hidden)]

fn assert_receiver_is_total_eq(&self)

👎Deprecated since 1.95.0:

implementation detail of #[derive(Eq)]

#[doc(hidden)]

fn assert_fields_are_eq(&self)

🔬This is a nightly-only experimental API. (derive_eq_internals)

impl Hash for RSidecar

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for RSidecar

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for RSidecar

impl TrivialClone for RSidecar

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 0 bytes