Struct wrapped_mono::Array

pub struct Array<Dim: DimensionTrait, T: InteropSend + InteropRecive + InteropClass>where
    Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy,
    <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>,
    <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy,{ /* private fields */ }

Safe, rust representation of MonoArray (a reference to a managed array).

Nullable support

Array<T> is non-nullable on default and will panic when null passed as argument form managed code. For nullable support use Option<Array<T>>.

Implementations

impl<T: InteropSend + InteropRecive + InteropClass, Dim: DimensionTrait> Array<Dim, T>where Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy, <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>, <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy, <Dim as DimensionTrait>::Lengths: BorrowMut<[usize]>,

pub fn get(&self, indices: Dim::Lengths) -> T

Function returning element at index

Arguments

Name	Type	Description
self	&Self	Array to read from.
indices	[usize;DIMENSIONS as usize]	An n-dimensional array containing indices to read value at

Examples

fn some_get_fn(input:&Array<Dim1D,f32>)->f32{
    let a = input.get([0]);  
    let b = input.get([1]);
    a + b
}

fn some_get_fn_2D(input:&Array<Dim2D,f32>)->f32{
    let a = input.get([0,0]);  
    let b = input.get([1,1]);
    let c = input.get([0,1]);
     a + b + c
}

pub fn set(&mut self, indices: Dim::Lengths, value: T)

Function setting element at index of Array to value

Arguments

Name	Type	Description
self	&Self	Array to write value to.
indices	[usize;DIMENSIONS as usize]	An n-dimensional array containing indices to set value at
value	T	value to set element at index to.

Example

fn set_fn(input:&mut Array<Dim1D,i32>){
    input.set([0],0);
    input.set([1],1);
}

fn set_fn_2D(input:&mut Array<Dim2D,i32>){
    input.set([0,0],0);
    input.set([1,1],1);
    input.set([1,0],9);
}

pub fn len(&self) -> usize

Function returning 1D length of the array(element count).

Arguments

Name	Type	Description
self	&Self	Array to get length of

Example

fn get_avg(input:&Array<Dim1D,f32>)->f32{
    let mut sum = 0.0;
    for i in 0..input.len(){
        sum += input.get([i]);
    }
    sum/(input.len() as f32)
}

pub fn is_empty(&self) -> bool

Checks if Array is empty.

Arguments

Name	Type	Description
self	&Self	Array to check if is empty

pub fn to_object(&self) -> Object

Converts Array to Object

Arguments

Name	Type	Description
self	&Array	array to cast to object

pub fn new(domain: &Domain, size: &Dim::Lengths) -> Self

Allocate new array in domain with size DIMENSIONS with elements of type class.

Example

let arr_len = 8;
let arr = Array::<Dim1D,i32>::new(&domain,&[arr_len]);
assert!(arr.len() == arr_len);

Arguments

Name	Type	Description
domain	&Domain	domain to create array in
size	&[usize;DIMENSIONS as usize]	size of the array to create

pub fn clone_managed_array(&self) -> Self

Clones managed array, not the reference to it.

Arguments

Name	Type	Description
self	&Array	Array to clone

pub fn get_class() -> Class

Returns class of this array

pub fn get_lenghts(&self) -> Dim::Lengths

Returns n-dimensional length of this array.

Arguments

Name	Type	Description
self	&Array	Array to get size of

Trait Implementations

impl<Dim: DimensionTrait, T: InteropSend + InteropRecive + InteropClass> Clone for Array<Dim, T>where Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy, <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>, <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: InteropSend + InteropRecive + InteropClass + Clone> From<&[T]> for Array<Dim1D, T>

fn from(src: &[T]) -> Self

Converts to this type from the input type.

impl<Dim: DimensionTrait, T: InteropSend + InteropRecive + InteropClass> InteropClass for Array<Dim, T>where Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy, <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>, <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy,

fn get_mono_class() -> Class

impl<Dim: DimensionTrait, T: InteropSend + InteropRecive + InteropClass> ObjectTrait for Array<Dim, T>where Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy, <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>, <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy,

fn get_ptr(&self) -> *mut MonoObject

Gets the internal [MonoObject] pointer.

unsafe fn from_ptr_unchecked(ptr: *mut MonoObject) -> Self

Creates new instance of Self from *mut [MonoObject]. Pointer is guaranteed to be not null, and of type which can be assigned to managed type represented by Self.

fn cast<Target: ObjectTrait>(&self) -> Option<Target>

unsafe fn from_ptr(obj_ptr: *mut MonoObject) -> Option<Self>

Creates new instance of Self from *mut [MonoObject]. Returns None if either obj_ptr is null OR object obj_ptr points to is of a type which does not derive from the managed type Self represents.

fn hash(&self) -> i32

get hash of this object: This hash is not based on values of objects fields, and differs from result of calling object.GetHash()

fn get_domain(&self) -> Domain

get Domain this object exists in.

fn get_size(&self) -> u32

get size of managed object referenced by self in bytes. Does include builtin hidden data.

fn get_class(&self) -> Class

Returns Class of this object. NOTE: This is function returns the class of the underlying object, not class represented by Self. This means that class returned from get_class may be a class derived from class Self represents.

fn to_mstring(&self) -> Result<Option<MString>, Exception>

Returns result of calling ToString on this Object.

impl<Dim: DimensionTrait, T: InteropSend + InteropRecive + InteropClass, O: ObjectTrait> PartialEq<O> for Array<Dim, T>where Dim::Lengths: IndexMut<usize> + BorrowMut<[usize]> + Copy, <Dim::Lengths as Index<usize>>::Output: BorrowMut<usize>, <<Dim as DimensionTrait>::Lengths as Index<usize>>::Output: Sized + Into<usize> + Copy,

fn eq(&self, other: &O) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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