Struct Struct 

pub struct Struct<P>(/* private fields */);

ND Structure array.

Implementations

impl<'p, P: MatlabPtr + 'p> Struct<P>

pub fn into_scalar(self) -> Result<ScalarStruct<P>, Self>

If the structure array only holds one element, convert it to a type that reflects that

pub fn field_number(&self, field: &CStr) -> Result<i32, StructError>

Determine the field number for some field name.

NOTE: field numbers are not static; if a new field is added or removed the field numbers change. The only reliable way accessing fields is via their name.

pub fn field_name(&self, fieldnum: i32) -> Result<&'p CStr, StructError>

Determine the field name of the fieldnumth field.

pub fn field_names(&self) -> impl Iterator<Item = &'p CStr> + '_

Iterate over all the field names of this struct

pub fn get<I: Index, F: FieldIndex>( &self, idx: I, field: F, ) -> Result<Option<&'p mxArray>, StructError>

Get the field of some structure within this array.

pub fn fields<F: FieldIndex>( &self, field: F, ) -> Result<impl Iterator<Item = Option<&'p mxArray>> + '_, StructError>

Get an iterator which returns references to the fields of each child structure. So, e.g.: s(1).field, s(2).field, etc.

impl<'p, P: MutMatlabPtr + 'p> Struct<P>

pub fn as_ref_struct<'s>(&'s self) -> Struct<&'s mxArray>

pub fn get_mut<I: Index, F: FieldIndex>( &mut self, idx: I, field: F, ) -> Result<Option<&'p mut mxArray>, StructError>

Get a mutable access to the field of some child struct.

pub fn set<I: Index, F: FieldIndex>( &mut self, idx: I, field: F, value: MxArray, ) -> Result<Option<MxArray>, StructError>

Set the value of a field of some child struct. Returns the previous value, if there was any.

pub fn replace<I: Index, F: FieldIndex>( &mut self, idx: I, field: F, value: Option<MxArray>, ) -> Result<Option<MxArray>, StructError>

Replace the current value of some child struct. This can be either None (removing the element), or Some(value) (in which case it replaces the old value). In either case, it returns what was previously there, which can also be None or Some(value).

pub fn unset<I: Index, F: FieldIndex>( &mut self, idx: I, field: F, ) -> Result<Option<MxArray>, StructError>

Unset a struct field by setting it to None. See replace.

pub fn fields_mut<F: FieldIndex>( &mut self, field: F, ) -> Result<impl Iterator<Item = Option<&'p mut mxArray>> + '_, StructError>

Return an iterator, returning mutable references to a field on each struct in the array, as with Struct::fields.

pub fn fields_values<F: FieldIndex>( &mut self, field: F, ) -> Result<impl Iterator<Item = Option<MxArray>> + '_, StructError>

Return an iterator, yielding the values of a field on each struct in the array. This will set each yielded field to None. Also see Struct::fields.

pub fn add_field(&mut self, field: &CStr) -> Result<i32, i32>

Add a field to the structure array. If the field does not yet exist, it returns Ok(new_field_num); if the field already exists it returns Err(existing_field_number).

Since no values for the fields are provided, they are initialised with None.

If you’re not interested in whether the field existed or not, you can obtain the field number to the field you wanted to add with:

use std::convert::identity as idtt;
let fieldnum = s.add_field(name).map_or_else(idtt, idtt)

NOTE that the field number is not static; if the structure array layout is mutated (e.g. a new field being added or removed), the field numbers for the fields may change.

pub fn remove_field<F: FieldIndex>( &mut self, field: F, ) -> Result<(), StructError>

Remove a field from a structure array without dropping and freeing their values. See Struct::delete_field instead

pub fn delete_field<F: FieldIndex>( &mut self, field: F, ) -> Result<(), StructError>

Removes a field from a structure array, dropping and freeing their resources in the process.

impl Struct<MxArray>

pub fn new_empty_with_fields(fieldnames: &[&CStr]) -> Self

Create an empty struct but with field names.

pub fn new(shape: &[usize], fieldnames: &[&CStr]) -> Self

Create a new structure array with the given fieldnames.

Methods from Deref<Target = mxArray>

pub fn duplicate(&self) -> MxArray

Create a deep copy of the array, and return as an owned type. However, consider using MatlabClass::duplicate instead if you are already working with MatlabClasses.

pub fn dimensions(&self) -> &[usize]

Return the sizes of the constituent dimensions of the mxArray

pub fn numel(&self) -> usize

Return the number of elements contained in this array.

pub fn raw_class_id(&self) -> u32

Return the raw class ID; the number Matlab returns.

pub fn class_id(&self) -> Result<ClassID, u32>

Return Ok(ClassID) for mxArrays which map to a built-in class (such as numeric arrays, structure arrays, and cell arrays (see ClassID); otherwise it returns the raw class ID in the Err variant. These other values of the raw class ID are used in modern versions of Matlab for custom classes, defined via e..g classdef.

pub fn is_complex(&self) -> bool

Check whether the backing array is complex. Since the only arrays which can be complex are numeric arrays, this also implies that.

pub fn is_sparse(&self) -> bool

Check whether the backing array is a sparse matrix

pub fn is_struct(&self) -> bool

Check whether the backing array is a struct array

pub fn is_empty(&self) -> bool

Check whether the backing array is empty

pub fn is_scalar(&self) -> bool

Check whether the backing array only holds one element

pub fn complexity(&self) -> Complexity

Trait Implementations

impl<P: Clone> Clone for Struct<P>

fn clone(&self) -> Struct<P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Debug> Debug for Struct<P>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<P> Deref for Struct<P>

where P: MatlabPtr,

type Target = mxArray_tag

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<P> DerefMut for Struct<P>

where P: MutMatlabPtr,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a> FromMatlab<'a> for Struct<&'a mxArray>

fn from_matlab(mx: &'a mxArray) -> Result<Self, FromMatlabError<&'a mxArray>>

impl<P: Hash> Hash for Struct<P>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'p, P: MatlabPtr + 'p> MatlabClass<P> for Struct<P>

type Owned = Struct<MxArray>

The owned variant of this matlab class.

fn from_mx_array(mx: P) -> Result<Self, FromMatlabError<P>>

Try to build a matlab class from a MatlabPtr. If the type requirements of the class match what the pointer is, then the class is constructed. Otherwise, an error is returned; containing the reason of the failure and the original pointer. The latter is especially useful with MxArrays; the owned MatlabPtr type — otherwise it would be dropped.

fn into_inner(self) -> P

Deconstruct the MatlabClass back to a bare MatlabPtr.

fn inner(&self) -> &P

Get a reference to the inner MatlabPtr. However, note that for &mxArray and &mut mxArray, the returned references will be of type &&mxArray and &&mut mxArray.

fn duplicate(&self) -> Self::Owned

Make a deep clone of the inner MatlabPtr, and construct an Owned MatlabClass from it.

impl<'p, P: MutMatlabPtr + 'p> MutMatlabClass<P> for Struct<P>

type AsBorrowed<'a> = Struct<&'a mxArray_tag> where P: 'a

fn as_borrowed<'a>(&'a self) -> Self::AsBorrowed<'a>

fn inner_mut(&mut self) -> &mut P

impl NewEmpty for Struct<MxArray>

fn new_empty() -> Self

Construct the empty type

impl OwnedMatlabClass for Struct<MxArray>

type AsMutable<'a> = Struct<&'a mut mxArray_tag> where Self: 'a

The way this class would be represented if it were a mutable borrow.

fn as_mutable<'a>(&'a mut self) -> Self::AsMutable<'a>

Create a MutMatlabClass from this owned instance.

impl<P: PartialEq> PartialEq for Struct<P>

fn eq(&self, other: &Struct<P>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<P: Copy> Copy for Struct<P>

impl<P: Eq> Eq for Struct<P>

impl<P> StructuralPartialEq for Struct<P>