twizzler/ptr/resolved/
resolved_slice_mut.rs

1use std::{
2    borrow::{Borrow, BorrowMut},
3    ops::{Deref, DerefMut, Index, IndexMut, RangeBounds},
4};
5
6use twizzler_rt_abi::object::ObjectHandle;
7
8use super::{Ref, RefMut, RefSlice};
9use crate::{ptr::GlobalPtr, util::range_bounds_to_start_and_end};
10
11pub struct RefSliceMut<'a, T> {
12    ptr: RefMut<'a, T>,
13    len: usize,
14}
15
16impl<'a, T> RefSliceMut<'a, T> {
17    pub unsafe fn from_ref(ptr: RefMut<'a, T>, len: usize) -> Self {
18        Self { ptr, len }
19    }
20
21    pub fn offset(&self) -> u64 {
22        self.ptr.offset()
23    }
24
25    pub fn as_slice(&self) -> &'a [T] {
26        unsafe { core::slice::from_raw_parts(self.ptr.raw(), self.len) }
27    }
28
29    pub fn as_slice_mut(&mut self) -> &'a mut [T] {
30        unsafe { core::slice::from_raw_parts_mut(self.ptr.raw(), self.len) }
31    }
32
33    #[inline]
34    pub fn get_ref(&self, idx: usize) -> Option<Ref<'a, T>> {
35        let ptr = self.as_slice().get(idx)?;
36        Some(unsafe { Ref::from_ptr(ptr) })
37    }
38
39    #[inline]
40    pub fn get(&self, idx: usize) -> Option<&T> {
41        let ptr = self.as_slice().get(idx)?;
42        Some(ptr)
43    }
44
45    pub fn get_mut(&mut self, idx: usize) -> Option<RefMut<'a, T>> {
46        let ptr = self.as_slice_mut().get_mut(idx)?;
47        Some(unsafe { RefMut::from_ptr(ptr) })
48    }
49
50    #[inline]
51    pub fn get_into(mut self, idx: usize) -> Option<RefMut<'a, T>> {
52        let ptr = self.as_slice_mut().get_mut(idx)? as *mut T;
53        Some(RefMut::new(ptr, self.ptr.lazy_handle))
54    }
55
56    pub fn len(&self) -> usize {
57        self.len
58    }
59
60    pub fn handle(&self) -> &ObjectHandle {
61        self.ptr.handle()
62    }
63
64    #[inline]
65    pub fn slice(mut self, range: impl RangeBounds<usize>) -> Self {
66        let (start, end) = range_bounds_to_start_and_end(self.len, range);
67        let len = end - start;
68        if let Some(r) = self.get_mut(start) {
69            unsafe { Self::from_ref(r, len) }
70        } else {
71            unsafe { Self::from_ref(self.ptr, 0) }
72        }
73    }
74
75    pub fn into_ref_slice(self) -> RefSlice<'a, T> {
76        let len = self.len();
77        unsafe { RefSlice::from_ref(self.ptr.into_ref(), len) }
78    }
79
80    pub fn as_ref_slice(&self) -> RefSlice<'a, T> {
81        unsafe { RefSlice::from_ref(self.ptr.as_ref().owned(), self.len()) }
82    }
83}
84
85impl<'a, T> From<RefSliceMut<'a, T>> for GlobalPtr<T> {
86    fn from(value: RefSliceMut<'a, T>) -> Self {
87        GlobalPtr::new(value.handle().id(), value.offset())
88    }
89}
90
91impl<'a, T> Index<usize> for RefSliceMut<'a, T> {
92    type Output = T;
93
94    fn index(&self, index: usize) -> &Self::Output {
95        let slice = self.as_slice();
96        &slice[index]
97    }
98}
99
100impl<'a, T> IndexMut<usize> for RefSliceMut<'a, T> {
101    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
102        let slice = self.as_slice_mut();
103        &mut slice[index]
104    }
105}
106
107impl<'a, T> Deref for RefSliceMut<'a, T> {
108    type Target = [T];
109
110    fn deref(&self) -> &Self::Target {
111        self.as_slice()
112    }
113}
114
115impl<'a, T> DerefMut for RefSliceMut<'a, T> {
116    fn deref_mut(&mut self) -> &mut Self::Target {
117        self.as_slice_mut()
118    }
119}
120
121impl<'a, T> AsRef<[T]> for RefSliceMut<'a, T> {
122    fn as_ref(&self) -> &[T] {
123        &*self
124    }
125}
126
127impl<'a, T> AsMut<[T]> for RefSliceMut<'a, T> {
128    fn as_mut(&mut self) -> &mut [T] {
129        &mut *self
130    }
131}
132
133impl<'a, T> Borrow<[T]> for RefSliceMut<'a, T> {
134    fn borrow(&self) -> &[T] {
135        &*self
136    }
137}
138
139impl<'a, T> BorrowMut<[T]> for RefSliceMut<'a, T> {
140    fn borrow_mut(&mut self) -> &mut [T] {
141        &mut *self
142    }
143}
144
145impl<'a, T> Into<ObjectHandle> for RefSliceMut<'a, T> {
146    fn into(self) -> ObjectHandle {
147        self.handle().clone()
148    }
149}
150
151impl<'a, T> Into<ObjectHandle> for &RefSliceMut<'a, T> {
152    fn into(self) -> ObjectHandle {
153        self.handle().clone()
154    }
155}
156
157impl<'a, T> AsRef<ObjectHandle> for RefSliceMut<'a, T> {
158    fn as_ref(&self) -> &ObjectHandle {
159        self.handle()
160    }
161}
twizzler/ptr/resolved/resolved_slice_mut.rs

twizzler/ptr/resolved/
resolved_slice_mut.rs
