Struct roxido::r::Rval

#[repr(C)]
pub struct Rval(pub SEXP);

A Rust representation of an R object.

Technically, this is simply a Rust new type idiom (newtype) for R’s SEXP, a pointer to R’s SEXPREC structure.

Tuple Fields

0: SEXP

Implementations

impl Rval

pub fn new_vector_double(len: usize, pc: &mut Pc) -> (Self, &'static mut [f64])

Define a new vector with storage mode double.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_vector_integer(len: usize, pc: &mut Pc) -> (Self, &'static mut [i32])

Define a new vector with storage mode integer.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_vector_logical(len: usize, pc: &mut Pc) -> (Self, &'static mut [i32])

Define a new vector with storage mode logical.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_vector_character(len: usize, pc: &mut Pc) -> Self

Define a new vector with storage mode character.

pub fn new_vector_raw(len: usize, pc: &mut Pc) -> (Self, &'static mut [u8])

Define a new vector with storage mode raw.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_matrix_double(
    nrow: usize,
    ncol: usize,
    pc: &mut Pc
) -> (Self, &'static mut [f64])

Define a new matrix with storage mode double.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_matrix_integer(
    nrow: usize,
    ncol: usize,
    pc: &mut Pc
) -> (Self, &'static mut [i32])

Define a new matrix with storage mode integer.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_matrix_logical(
    nrow: usize,
    ncol: usize,
    pc: &mut Pc
) -> (Self, &'static mut [i32])

Define a new matrix with storage mode logical.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn new_matrix_character(nrow: usize, ncol: usize, pc: &mut Pc) -> Self

Define a new matrix with storage mode character.

pub fn new_list(len: usize, pc: &mut Pc) -> Self

Define a new list.

pub fn new_error(message: &str, pc: &mut Pc) -> Self

Define a new error.

This does not throw an error. Instead, simply use panic!.

pub fn new_character(x: &str, pc: &mut Pc) -> Self

Define a new element for a character vector.

An element of a character vector should generally not be returned to a user, but this function can be used in conjunction with Self::set_character_element.

pub fn new_symbol(x: &str, pc: &mut Pc) -> Self

Define a new symbol.

pub fn duplicate(self, pc: &mut Pc) -> Self

Duplicate an object.

When assignments are done in R such as

Since multiple symbols may be bound to the same object, if the usual R semantics are to apply, any code which alters one of them needs to make a copy before modifying the copy. This method is commonly called on arguments to .Call before modifying them.

pub fn nil() -> Self

Get the value NULL.

pub fn infinity_positive() -> f64

Get R’s definition of the Inf value.

pub fn infinity_negative() -> f64

Get R’s definition of the -Inf value.

pub fn nan() -> f64

Get R’s definition of the NaN value.

pub fn na_double() -> f64

Get R’s definition of the NA value of storage mode double.

pub fn na_integer() -> i32

Get R’s definition of the NA value of storage mode integer.

pub fn na_logical() -> i32

Get R’s definition of the NA value of storage mode logical.

pub fn na_character() -> Self

Get R’s definition of the NA value for an element of an object of storage mode character.

pub fn is_finite(x: f64) -> bool

Test if value is finite.

pub fn is_nan(x: f64) -> bool

Test if value is NaN.

pub fn is_na_double(x: f64) -> bool

Test if value is NA for storage mode double.

pub fn is_na_integer(x: i32) -> bool

Test if value is NA for storage mode integer.

pub fn is_na_logical(x: i32) -> bool

Test if value is NA for storage mode logical.

pub fn is_na_character(self) -> bool

Test if value is NA for an element of an object of storage mode character.

pub fn is_double(self) -> bool

Is the object of storage mode double?

pub fn is_integer(self) -> bool

Is the object of storage mode integer?

pub fn is_double_or_integer(self) -> bool

Is the object of storage mode double or integer?

pub fn is_double_or_integer_scalar(self) -> bool

Is the object of storage mode double or integer and of length one?

pub fn is_logical(self) -> bool

Is the object of storage mode logical?

pub fn is_raw(self) -> bool

Is the object of storage mode raw?

pub fn is_symbol(self) -> bool

Is the object a symbol?

pub fn is_character_element(self) -> bool

Is the object an element of an object of storage mode character?

pub fn is_character(self) -> bool

Is the object of storage mode character?

pub fn is_list(self) -> bool

Is the object a list?

pub fn is_vector_atomic(self) -> bool

Is the object an atomic vector?

pub fn is_vector(self) -> bool

Is the object a vector?

pub fn is_scalar(self) -> bool

Is the object of length one?

pub fn is_matrix(self) -> bool

Is the object a matrix?

pub fn is_square_matrix(self) -> bool

Is the object a square matrix?

pub fn is_array(self) -> bool

Is the object an array?

pub fn is_data_frame(self) -> bool

Is the object a data.frame?

pub fn is_nil(self) -> bool

Is the object NULL?

pub fn is_function(self) -> bool

Is the object a function?

pub fn is_environment(self) -> bool

Is the object an environment?

pub fn is_true(self) -> bool

Can the object be interpreted as TRUE?

pub fn is_false(self) -> bool

Can the object be interpreted as FALSE?

pub fn get_character_element(self, i: usize) -> Self

Get an element of a character vector, with indexing starting at zero.

Panics

This function panics if the object is not a character vector or if i is greater than or equal to the length of the vector.

pub fn set_character_element(self, i: usize, value: &str)

Set an element of a character vector, with indexing starting at zero.

Panics

This function panics if the object is not a character vector or if i is greater than or equal to the length of the vector.

pub fn get_list_element(self, i: usize) -> Self

Get an element of a list, with indexing starting at zero.

Panics

This function panics if the object is not a list or if i is greater than or equal to the length of the list.

pub fn set_list_element(self, i: usize, value: Self)

Set an element of a list, with indexing starting at zero.

Panics

This function panics if the object is not a list or if i is greater than or equal to the length of the list.

pub fn get_attribute(self, which: &str, pc: &mut Pc) -> Self

Get an attribute.

pub fn set_attribute(self, which: &str, value: Self, pc: &mut Pc)

Set an attribute.

pub fn assign(self, value: Self, environment: Self)

Create a new binding (or changes the value of an existing binding) in the specified environment frame. It is the analogue of assign(self, value, envir = environment, inherits = FALSE).

Panics

The function panics if the object is not a symbol.

pub fn assign_inherits(self, value: Self, environment: Self)

Search for an existing binding in the specified environment or its enclosing environments. If a binding is found, its value is changed to value. Otherwise, a new binding is created in the global environment. This corresponds to assign(self, value, envir = environment, inherits = TRUE).

Panics

The function panics if the object is not a symbol.

pub fn names_gets(self, names: Self)

Set the names attribute of an object.

Panics

The function panics if names is not an vector object of the same length as the object.

pub fn class_gets(self, value: Self)

Set the class attribute of an object.

Panics

The function panics if value is not a character vector.

pub fn len(self) -> usize

Get the length of the object.

pub fn is_empty(self) -> bool

Is the length of the object zero?

pub fn as_f64(self) -> f64

Coerce the object to an f64 value (potentially leading to an NA/NaN value).

pub fn as_i32(self) -> i32

Coerce the object to an i32 value (potentially leading to an NA/NaN value).

pub fn as_bool(self) -> bool

Coerce the object to a bool value (potentially leading to an NA/NaN value).

pub fn as_usize(self) -> usize

Coerce the object to a usize value (potentially leading to an NA/NaN value), setting negative values to zero.

pub fn as_string(self) -> String

Coerce the object to storage mode character and get the associated String value.

If coercion is not possible (because, for example, no UTF-8 representation exists), "" is returned.

pub fn nrow(self) -> usize

Get the number of rows in a matrix.

Panics

The function panics if the object is not a matrix.

pub fn ncol(self) -> usize

Get the number of columns in a matrix.

Panics

The function panics if the object is not a matrix.

pub fn transpose(self, pc: &mut Pc) -> Self

Transpose a matrix.

Panics

The function panics if the object is not a matrix.

pub fn slice_double(self) -> Result<&'static mut [f64], &'static str>

Get an f64 slice associated with the object, or an error if the object is not of storage mode double.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn slice_integer(self) -> Result<&'static mut [i32], &'static str>

Get an i32 slice associated with the object, or an error if the object is not of storage mode integer.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn slice_logical(self) -> Result<&'static mut [i32], &'static str>

Get an i32 slice (of logical values) associated with the object, or an error if the object is not of storage mode logical.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn slice_raw(self) -> Result<&'static mut [u8], &'static str>

Get an u8 slice associated with the object, or an error if the object is not of storage mode raw.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn coerce_double(
    self,
    pc: &mut Pc
) -> Result<(Self, &'static mut [f64]), &'static str>

Coerce the object to storage mode double and get the associated slice, or return an error if not possible.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn coerce_integer(
    self,
    pc: &mut Pc
) -> Result<(Self, &'static mut [i32]), &'static str>

Coerce the object to storage mode integer and get the associated slice, or return an error if not possible.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn coerce_logical(
    self,
    pc: &mut Pc
) -> Result<(Self, &'static mut [i32]), &'static str>

Coerce the object to storage mode logical and get the associated slice, or return an error if not possible.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn coerce_raw(
    self,
    pc: &mut Pc
) -> Result<(Self, &'static mut [u8]), &'static str>

Coerce the object to storage mode raw and get the associated slice, or return an error if not possible.

Although the stated lifetime is 'static, the reference is actually only valid as long as the associated R object exists.

pub fn coerce_character(self, pc: &mut Pc) -> Result<Self, &'static str>

Coerce the object to storage mode character, or return an error if not possible.

pub unsafe fn call0_unsafe(self, pc: &mut Pc) -> Self

Call a function with no arguments.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call0 is the safe alternative, with slightly more overhead.

pub unsafe fn call1_unsafe(self, x1: Self, pc: &mut Pc) -> Self

Call a function with one argument.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call1 is the safe alternative, with slightly more overhead.

pub unsafe fn call2_unsafe(self, x1: Self, x2: Self, pc: &mut Pc) -> Self

Call a function with two arguments.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call2 is the safe alternative, with slightly more overhead.

pub unsafe fn call3_unsafe(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    pc: &mut Pc
) -> Self

Call a function with three arguments.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call3 is the safe alternative, with slightly more overhead.

pub unsafe fn call4_unsafe(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    x4: Self,
    pc: &mut Pc
) -> Self

Call a function with four arguments.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call4 is the safe alternative, with slightly more overhead.

pub unsafe fn call5_unsafe(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    x4: Self,
    x5: Self,
    pc: &mut Pc
) -> Self

Call a function with five arguments.

Safety

This function will cause a long jump (leading to a memory leak) if the R function throws any errors. Using Self::call5 is the safe alternative, with slightly more overhead.

pub fn eval(self, environment: Self, pc: &mut Pc) -> Result<Self, i32>

Evaluation a expression, returning the value or an error code.

pub fn call0(self, pc: &mut Pc) -> Result<Self, i32>

Call a function with no arguments, returning the value or an error code.

pub fn call1(self, x1: Self, pc: &mut Pc) -> Result<Self, i32>

Call a function with one argument, returning the value or an error code.

pub fn call2(self, x1: Self, x2: Self, pc: &mut Pc) -> Result<Self, i32>

Call a function with two arguments, returning the value or an error code.

pub fn call3(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    pc: &mut Pc
) -> Result<Self, i32>

Call a function with three arguments, returning the value or an error code.

pub fn call4(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    x4: Self,
    pc: &mut Pc
) -> Result<Self, i32>

Call a function with four arguments, returning the value or an error code.

pub fn call5(
    self,
    x1: Self,
    x2: Self,
    x3: Self,
    x4: Self,
    x5: Self,
    pc: &mut Pc
) -> Result<Self, i32>

Call a function with five arguments, returning the value or an error code.

Trait Implementations

impl Clone for Rval

fn clone(&self) -> Rval

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<Rval> for f64

fn from(x: Rval) -> f64

Performs the conversion.

impl From<Rval> for i32

fn from(x: Rval) -> i32

Performs the conversion.

impl NewProtected<&'_ [&'_ str]> for Rval

fn new(x: &[&str], pc: &mut Pc) -> Self

impl NewProtected<&'_ [f64]> for Rval

fn new(x: &[f64], pc: &mut Pc) -> Self

impl NewProtected<&'_ [i32]> for Rval

fn new(x: &[i32], pc: &mut Pc) -> Self

impl NewProtected<&'_ [u8]> for Rval

fn new(x: &[u8], pc: &mut Pc) -> Rval

impl NewProtected<&'_ String> for Rval

fn new(x: &String, pc: &mut Pc) -> Self

impl NewProtected<&'_ mut [f64]> for Rval

fn new(x: &mut [f64], pc: &mut Pc) -> Self

impl NewProtected<&'_ mut [i32]> for Rval

fn new(x: &mut [i32], pc: &mut Pc) -> Self

impl NewProtected<&'_ mut [u8]> for Rval

fn new(x: &mut [u8], pc: &mut Pc) -> Rval

impl NewProtected<&'_ str> for Rval

fn new(x: &str, pc: &mut Pc) -> Self

impl<const LENGTH: usize> NewProtected<[&'_ str; LENGTH]> for Rval

fn new(x: [&str; LENGTH], pc: &mut Pc) -> Self

impl<const N: usize> NewProtected<[f64; N]> for Rval

fn new(x: [f64; N], pc: &mut Pc) -> Self

impl<const N: usize> NewProtected<[i32; N]> for Rval

fn new(x: [i32; N], pc: &mut Pc) -> Self

impl<const N: usize> NewProtected<[u8; N]> for Rval

fn new(x: [u8; N], pc: &mut Pc) -> Self

impl NewProtected<String> for Rval

fn new(x: String, pc: &mut Pc) -> Self

impl NewProtected<bool> for Rval

fn new(x: bool, pc: &mut Pc) -> Self

impl NewProtected<f64> for Rval

fn new(x: f64, pc: &mut Pc) -> Self

impl NewProtected<i32> for Rval

fn new(x: i32, pc: &mut Pc) -> Self

impl TryFrom<Rval> for bool

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<bool, Self::Error>

Performs the conversion.

impl TryFrom<Rval> for usize

type Error = TryFromIntError

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<usize, Self::Error>

Performs the conversion.

impl TryFrom<Rval> for *const i32

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*const i32, &'static str>

Performs the conversion.

impl TryFrom<Rval> for *mut i32

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*mut i32, &'static str>

Performs the conversion.

impl TryFrom<Rval> for *const u8

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*const u8, &'static str>

Performs the conversion.

impl TryFrom<Rval> for *mut u8

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*mut u8, &'static str>

Performs the conversion.

impl TryFrom<Rval> for &str

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static str, &'static str>

Performs the conversion.

impl TryFrom<Rval> for &[f64]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static [f64], &'static str>

Performs the conversion.

impl TryFrom<Rval> for &mut [f64]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static mut [f64], &'static str>

Performs the conversion.

impl TryFrom<Rval> for &[i32]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static [i32], &'static str>

Performs the conversion.

impl TryFrom<Rval> for &mut [i32]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static mut [i32], &'static str>

Performs the conversion.

impl TryFrom<Rval> for &[u8]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static [u8], &'static str>

Performs the conversion.

impl TryFrom<Rval> for &mut [u8]

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<&'static mut [u8], &'static str>

Performs the conversion.

impl TryFrom<Rval> for *const f64

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*const f64, &'static str>

Performs the conversion.

impl TryFrom<Rval> for *mut f64

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(x: Rval) -> Result<*mut f64, &'static str>

Performs the conversion.

impl TryNewProtected<usize> for Rval

type Error = TryFromIntError

fn try_new(x: usize, pc: &mut Pc) -> Result<Self, Self::Error>

impl Copy for Rval