rustmex 0.6.4

Rustmex: providing convenient Rust bindings to Matlab MEX API's
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

/*!
 * Character arrays
 */

use std::ffi::{CString, c_char};
use core::ops::{Deref, DerefMut};

use rustmex_core::{
	mxArray,
	pointers::{MatlabPtr, MutMatlabPtr, MxArray},
	convert::{FromMatlabError},

	MatlabClass,
	MutMatlabClass,
	OwnedMatlabClass,
	NewEmpty,
};

/**
 * Wrapper for a character array
 */
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct CharArray<P>(P);

impl<P> Deref for CharArray<P> where P: MatlabPtr {
	type Target = mxArray;

	fn deref(&self) -> &Self::Target {
		&self.0
	}
}

impl<P> DerefMut for CharArray<P> where P: MutMatlabPtr {
	fn deref_mut(&mut self) -> &mut Self::Target {
		&mut self.0
	}
}

extern "Rust" { fn rustmex_array_to_cstring(mx:*const mxArray) -> *mut c_char; }

impl<P> CharArray<P> where P: MatlabPtr {
	pub fn get_cstring(&self) -> CString {
		let ptr = unsafe { rustmex_array_to_cstring(self.0.deref()) };

		// we checked whether the array was an mxChar array, so the only
		// remaining option is an OOM-error.
		if ptr.is_null() {
			panic!("OOM")
		}

		unsafe { CString::from_raw(ptr) }
	}
}

impl<P> MatlabClass<P> for CharArray<P> where P: MatlabPtr {
	fn from_mx_array(mx: P) -> Result<Self, FromMatlabError<P>> {
		if mx.raw_class_id() != ::rustmex_core::classid::ClassID::Char {
			return Err(FromMatlabError::new_badclass(mx));
		}

		Ok(Self(mx))
	}

	fn into_inner(self) -> P {
		self.0
	}

	fn inner(&self) -> &P {
		&self.0
	}

	type Owned = CharArray<MxArray>;
	fn duplicate(&self) -> Self::Owned {
		CharArray(self.0.duplicate())
	}
}

impl<P> MutMatlabClass<P> for CharArray<P> where P: MutMatlabPtr {
	type AsBorrowed<'a> = CharArray<&'a mxArray> where Self: 'a;
	fn as_borrowed<'a>(&'a self) -> Self::AsBorrowed<'a> {
		CharArray(self.0.deref())
	}

	fn inner_mut(&mut self) -> &mut P {
		&mut self.0
	}
}

impl OwnedMatlabClass for CharArray<MxArray> {
	type AsMutable<'a> = CharArray<&'a mut mxArray> where Self: 'a;
	fn as_mutable<'a>(&'a mut self) -> Self::AsMutable<'a> {
		CharArray(self.0.deref_mut())
	}
}

impl NewEmpty for CharArray<MxArray> {
	fn new_empty() -> Self {
		unimplemented!()
	}
}