tesseract_swift_utils/
array.rs

1use super::error::CError;
2use super::ptr::SyncPtr;
3use super::result::Result;
4use super::traits::{QuickClone, TryAsRef, AsCRef};
5use std::borrow::Borrow;
6use std::mem::ManuallyDrop;
7
8#[repr(C)]
9#[derive(Debug)]
10pub struct CArrayRef<'a, Value> {
11    pub ptr: SyncPtr<Value>,
12    pub len: usize,
13    _lifecycle: std::marker::PhantomData<&'a Value>
14}
15
16impl<'a, Value> CArrayRef<'a, Value> {
17    pub fn cloned(&self) -> Result<Vec<Value>> where Value: Clone {
18        Ok(self.try_as_ref()?.iter().map(|v| v.clone()).collect())
19    }
20
21    pub fn quick_cloned(&self) -> Result<Vec<Value>> where Value: Copy {
22        Ok(self.try_as_ref()?.to_owned())
23    } 
24}
25
26impl<'a, Value> TryAsRef<[Value]> for CArrayRef<'a, Value> {
27    type Error = CError;
28
29    fn try_as_ref(&self) -> std::result::Result<&'a [Value], Self::Error> {
30        if self.ptr.is_null() {
31            Err(CError::null::<Self>())
32        } else {
33            unsafe { Ok(std::slice::from_raw_parts(self.ptr.ptr(), self.len)) }
34        }
35    }
36}
37
38impl<'a, Value, T> From<T> for CArrayRef<'a, Value> where T: Borrow<[Value]> {
39    fn from(value: T) -> Self {
40        let bw: &[Value] = value.borrow();
41        Self{ ptr: bw.as_ptr().into(), len: bw.len(), _lifecycle: std::marker::PhantomData } 
42    }
43}
44
45#[repr(C)]
46#[derive(Debug)]
47pub struct CArray<Value> {
48    pub ptr: SyncPtr<Value>,
49    pub len: usize,
50}
51
52impl<Value: Clone> Clone for CArray<Value> {
53    fn clone(&self) -> Self {
54        let vec: Vec<Value> = self
55            .try_as_ref()
56            .unwrap()
57            .iter()
58            .map(|v| v.clone())
59            .collect();
60        vec.into()
61    }
62}
63
64impl<Value: Copy> QuickClone for CArray<Value> {
65    fn quick_clone(&self) -> Self {
66        self.try_as_ref().unwrap().into()
67    }
68}
69
70impl<Value> Drop for CArray<Value> {
71    fn drop(&mut self) {
72        let _ = unsafe { Vec::from_raw_parts(self.ptr.ptr() as *mut Value, self.len, self.len) };
73        self.ptr = SyncPtr::null();
74    }
75}
76
77impl<'a, V> AsCRef<CArrayRef<'a, V>> for CArray<V> {
78    fn as_cref(&self) -> CArrayRef<'a, V> {
79        CArrayRef { ptr: self.ptr.ptr().into(), len: self.len, _lifecycle: std::marker::PhantomData }
80    }
81}
82
83impl<'a, V> AsCRef<CArrayRef<'a, V>> for Vec<V> {
84    fn as_cref(&self) -> CArrayRef<'a, V> {
85        CArrayRef { ptr: self.as_ptr().into(), len: self.len(), _lifecycle: std::marker::PhantomData }
86    }
87}
88
89impl<'a, V> AsCRef<CArrayRef<'a, V>> for &'a[V] {
90    fn as_cref(&self) -> CArrayRef<'a, V> {
91        CArrayRef { ptr: self.as_ptr().into(), len: self.len(), _lifecycle: std::marker::PhantomData }
92    }
93}
94
95impl<Value> TryAsRef<[Value]> for CArray<Value> {
96    type Error = CError;
97
98    fn try_as_ref(&self) -> Result<&[Value]> {
99        if self.ptr.is_null() {
100            Err(CError::null::<Self>())
101        } else {
102            unsafe { Ok(std::slice::from_raw_parts(self.ptr.ptr(), self.len)) }
103        }
104    }
105}
106
107impl<'a, Value> TryFrom<&'a CArray<Value>> for &'a [Value] {
108    type Error = CError;
109
110    fn try_from(value: &'a CArray<Value>) -> Result<Self> {
111        value.try_as_ref()
112    }
113}
114
115impl<Value> TryFrom<CArray<Value>> for Vec<Value> {
116    type Error = CError;
117
118    fn try_from(value: CArray<Value>) -> Result<Self> {
119        if value.ptr.is_null() {
120            Err(CError::null::<CArray<Value>>())
121        } else {
122            let value = ManuallyDrop::new(value); // This is safe. Memory will be owned by Vec
123            unsafe {
124                Ok(Vec::from_raw_parts(
125                    value.ptr.ptr() as *mut Value,
126                    value.len,
127                    value.len,
128                ))
129            }
130        }
131    }
132}
133
134impl<V1, V2: Into<V1> + Clone> From<&[V2]> for CArray<V1> {
135    fn from(array: &[V2]) -> Self {
136        Vec::from(array).into()
137    }
138}
139
140impl<V1, V2: Into<V1>> From<Vec<V2>> for CArray<V1> {
141    fn from(array: Vec<V2>) -> Self {
142        let mapped: Vec<V1> = array.into_iter().map(|v| v.into()).collect();
143        let mut mapped = ManuallyDrop::new(mapped.into_boxed_slice());
144        Self {
145            ptr: mapped.as_mut_ptr().into(),
146            len: mapped.len(),
147        }
148    }
149}
tesseract_swift_utils/array.rs

tesseract_swift_utils/
array.rs
