extendr_api/wrapper/
integers.rs

1use super::scalar::Rint;
2use super::*;
3use extendr_ffi::{
4    dataptr, R_xlen_t, INTEGER_GET_REGION, INTEGER_IS_SORTED, INTEGER_NO_NA, SET_INTEGER_ELT,
5};
6use std::iter::FromIterator;
7
8/// An obscure `NA`-aware wrapper for R's integer vectors.
9/// Can be used to iterate over vectors obtained from R
10/// or to create new vectors that can be returned back to R.
11/// ```
12/// use extendr_api::prelude::*;
13/// test! {
14///     let mut vec = (0..5).collect::<Integers>();
15///     vec.iter_mut().for_each(|v| *v = *v + 10);
16///     assert_eq!(vec.elt(0), 10);
17///     let sum = vec.iter().sum::<Rint>();
18///     assert_eq!(sum, 60);
19/// }
20/// ```
21#[derive(PartialEq, Clone)]
22pub struct Integers {
23    pub(crate) robj: Robj,
24}
25
26use extendr_ffi::SEXPTYPE::INTSXP;
27macros::gen_vector_wrapper_impl!(
28    vector_type: Integers, // Implements for
29    scalar_type: Rint,     // Element type
30    primitive_type: i32,   // Raw element type
31    r_prefix: INTEGER,     // `R` functions prefix
32    SEXP: INTSXP,          // `SEXP`
33    doc_name: integer,     // Singular type name used in docs
34    altrep_constructor: make_altinteger_from_iterator,
35);
36
37macros::gen_from_iterator_impl!(
38    vector_type: Integers,
39    collect_from_type: i32,
40    underlying_type: i32,
41    r_prefix: INTEGER,
42    SEXP: INTSXP
43);
44
45impl Integers {
46    /// Get a region of elements from the vector.
47    pub fn get_region(&self, index: usize, dest: &mut [Rint]) -> usize {
48        unsafe {
49            let ptr: *mut i32 = dest.as_mut_ptr() as *mut i32;
50            INTEGER_GET_REGION(self.get(), index as R_xlen_t, dest.len() as R_xlen_t, ptr) as usize
51        }
52    }
53
54    /// Return `TRUE` if the vector is sorted, `FALSE` if not, or `NA_BOOL` if unknown.
55    pub fn is_sorted(&self) -> Rbool {
56        unsafe { INTEGER_IS_SORTED(self.get()).into() }
57    }
58
59    /// Return `TRUE` if the vector has no `NA`s, `FALSE` if any, or `NA_BOOL` if unknown.
60    pub fn no_na(&self) -> Rbool {
61        unsafe { INTEGER_NO_NA(self.get()).into() }
62    }
63}
64
65// TODO: this should be a trait.
66impl Integers {
67    pub fn set_elt(&mut self, index: usize, val: Rint) {
68        single_threaded(|| unsafe {
69            SET_INTEGER_ELT(self.get(), index as R_xlen_t, val.0);
70        })
71    }
72}
73
74impl Deref for Integers {
75    type Target = [Rint];
76
77    /// Treat Integers as if it is a slice, like `Vec<Rint>`
78    fn deref(&self) -> &Self::Target {
79        unsafe {
80            let ptr = dataptr(self.get()) as *const Rint;
81            crate::robj::vector_slice(ptr, self.len())
82        }
83    }
84}
85
86impl DerefMut for Integers {
87    /// Treat Integers as if it is a mutable slice, like `Vec<Rint>`
88    fn deref_mut(&mut self) -> &mut Self::Target {
89        unsafe {
90            let ptr = dataptr(self.get_mut()) as *mut Rint;
91            crate::robj::vector_slice_mut(ptr, self.len())
92        }
93    }
94}
95
96impl std::fmt::Debug for Integers {
97    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
98        if self.len() == 1 {
99            write!(f, "{:?}", self.elt(0))
100        } else {
101            f.debug_list().entries(self.iter()).finish()
102        }
103    }
104}
105
106impl TryFrom<Vec<i32>> for Integers {
107    type Error = Error;
108
109    fn try_from(value: Vec<i32>) -> Result<Self> {
110        Ok(Self { robj: value.into() })
111    }
112}
113
114#[cfg(test)]
115mod tests {
116    use crate::prelude::*;
117
118    #[test]
119    fn from_iterator() {
120        test! {
121            let vec : Integers = (0..3).collect();
122            assert_eq!(vec, Integers::from_values([0, 1, 2]));
123        }
124    }
125
126    #[test]
127    fn iter_mut() {
128        test! {
129            let mut vec = Integers::from_values(0..3);
130            vec.iter_mut().for_each(|v| *v += 1);
131            assert_eq!(vec, Integers::from_values(1..4));
132        }
133    }
134
135    #[test]
136    fn iter() {
137        test! {
138            let vec = Integers::from_values(0..3);
139            assert_eq!(vec.iter().sum::<Rint>(), 3);
140        }
141    }
142
143    #[test]
144    fn from_values_short() {
145        test! {
146            // Short (<64k) vectors are allocated.
147            let vec = Integers::from_values((0..3).map(|i| 2-i));
148            assert_eq!(vec.is_altrep(), false);
149            assert_eq!(r!(vec.clone()), r!([2, 1, 0]));
150            assert_eq!(vec.elt(1), 1);
151            let mut dest = [0.into(); 2];
152            vec.get_region(1, &mut dest);
153            assert_eq!(dest, [1, 0]);
154        }
155    }
156
157    #[test]
158    fn from_values_altrep() {
159        test! {
160            let vec = Integers::from_values_altrep(0..1000000000);
161            assert_eq!(vec.is_altrep(), true);
162            assert_eq!(vec.elt(12345678), 12345678);
163            let mut dest = [0.into(); 2];
164            vec.get_region(12345678, &mut dest);
165            assert_eq!(dest, [12345678, 12345679]);
166        }
167    }
168
169    #[test]
170    fn new() {
171        test! {
172            let vec = Integers::new(10);
173            assert_eq!(vec.is_integer(), true);
174            assert_eq!(vec.len(), 10);
175        }
176    }
177
178    #[test]
179    fn new_with_na() {
180        test! {
181            let vec = Integers::new_with_na(10);
182            let manual_vec = (0..10).map(|_| Rint::na()).collect::<Integers>();
183            assert_eq!(vec, manual_vec);
184            assert_eq!(vec.len(), manual_vec.len());
185        }
186    }
187
188    #[test]
189    fn test_vec_i32_integers_conversion() {
190        test! {
191            let int_vec = vec![3,4,0,-2];
192            let int_vec_robj: Robj = int_vec.clone().into();
193            assert_eq!(int_vec_robj.as_integer_slice().unwrap(), &int_vec);
194        }
195    }
196}
extendr_api/wrapper/integers.rs

extendr_api/wrapper/
integers.rs
