Struct rutie::Array

#[repr(C)]
pub struct Array { /* private fields */ }

Array

Implementations

impl Array

pub fn new() -> Self

Creates a new instance of empty Array.

Examples

use rutie::{Array, VM};

Array::new();

Ruby:

[]

pub fn with_capacity(capacity: usize) -> Self

Creates a new instance of empty Array with reserved space for capacity elements.

Examples

use rutie::{Array, Fixnum, VM};

let mut array = Array::with_capacity(2);

assert_eq!(array.length(), 0);

array.push(Fixnum::new(1));
array.push(Fixnum::new(2));

assert_eq!(array.length(), 2);

Ruby:

[]

pub fn length(&self) -> usize

Retrieves the length of the array.

Examples

use rutie::{Array, Fixnum, VM};

let mut array = Array::new().push(Fixnum::new(1));

assert_eq!(array.length(), 1);

array.push(Fixnum::new(2));

assert_eq!(array.length(), 2);

Ruby:

array = [1]
array.length == 1

array << 2
array.length == 2

pub fn at(&self, index: i64) -> AnyObject

Retrieves an AnyObject from the element at index position.

Examples

use rutie::{Array, Fixnum, Object, VM};

let array = Array::new().push(Fixnum::new(1));

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

array = [1]

array[0] == 1

pub fn join(&self, separator: RString) -> RString

Joins all elements of Array to Ruby String.

Examples

use rutie::{Array, RString, VM};

let array = Array::new()
    .push(RString::new_utf8("Hello"))
    .push(RString::new_utf8("World!"));

let joined_string = array.join(RString::new_utf8(", "));

assert_eq!(joined_string.to_str(), "Hello, World!");

Ruby:

array = ['Hello', 'World!']

joined_string = array.join(', ')

joined_string == 'Hello, World!'

pub fn push<T: Object>(&mut self, item: T) -> Self

Pushes an object to Array.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new();

array.push(Fixnum::new(1));

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

array = []
array << 1

array[0] == 1

pub fn store<T: Object>(&mut self, index: i64, item: T)

Stores an object at index position.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1));

array.store(0, Fixnum::new(2));

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [1]
array[0] = 2

array[0] == 2

pub fn pop(&mut self) -> AnyObject

Removes and returns the last element of the array.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1));

assert_eq!(array.pop().try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

array = [1]

array.pop == 1

pub fn unshift<T: Object>(&mut self, item: T) -> Array

Inserts item at the beginning of the array.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1));

array.unshift(Fixnum::new(2));

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [1]
array.unshift(2)

array[0] == 2

pub fn shift(&mut self) -> AnyObject

Removes the first item of the array and returns it.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1)).push(Fixnum::new(2));

let item = array.shift();

assert_eq!(item.try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));
assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [1, 2]

item = array.shift

item == 1
array[0] == 2

pub fn dup(&self) -> Array

Creates a copy of the array.

Examples

use rutie::{Array, Fixnum, Object, VM};

let array = Array::new().push(Fixnum::new(1));
let copy = array.dup();

assert_eq!(array.at(0), copy.at(0));

Ruby:

array = [1]
copy = array.dup

array[0] == copy[0]

pub fn to_s(&self) -> RString

Creates a string representation of the array.

Examples

use rutie::{Array, Fixnum, VM};

let array = Array::new().push(Fixnum::new(1)).push(Fixnum::new(2));

assert_eq!(array.to_s().to_str(), "[1, 2]");

Ruby:

array = [1, 2]

array.to_s == "[1, 2]"

pub fn reverse(&self) -> Array

Returns a new array containing array’s elements in reverse order.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1)).push(Fixnum::new(2));

let reversed_array = array.reverse();

assert_eq!(reversed_array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));
assert_eq!(reversed_array.at(1).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

array = [1, 2]

reversed_array = array.reverse

reversed_array[0] == 2
reversed_array[1] == 1

pub fn reverse_bang(&mut self) -> Array

Reverses self in place.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1)).push(Fixnum::new(2));

array.reverse_bang();

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));
assert_eq!(array.at(1).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

array = [1, 2]

array.reverse!

array[0] == 2
array[1] == 1

pub fn concat(&mut self, other: &Array) -> Array

Appends the elements of other array to self.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(1));
let other = Array::new().push(Fixnum::new(2));

array.concat(&other);

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));
assert_eq!(array.at(1).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [1]
other = [2]

array.concat(other)

array[0] == 1
array[1] == 2

pub fn sort(&self) -> Array

Returns a new array created by sorting self.

Examples

use rutie::{Array, Fixnum, Object, VM};

let array = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1));

let sorted_array = array.sort();

assert_eq!(sorted_array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));
assert_eq!(sorted_array.at(1).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [2, 1]

sorted_array = array.sort

sorted_array[0] == 1
sorted_array[1] == 2

pub fn sort_bang(&mut self) -> Array

Sorts the array in place.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1));

array.sort_bang();

assert_eq!(array.at(0).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));
assert_eq!(array.at(1).try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

array = [2, 1]

array.sort!

array[0] == 1
array[1] == 2

pub fn to_enum(&self) -> Enumerator

Returns an Enumerator instance

Examples

use rutie::{Array, Fixnum, Object, VM, VerifiedObject, Enumerator};

let enumerator = Array::new().push(Fixnum::new(2)).push(Fixnum::new(1)).to_enum();

assert!(Enumerator::is_correct_type(&enumerator), "incorrect type!");

Ruby:

enumerator = [2, 1].to_enum

Enumerator === enumerator

Trait Implementations

impl Debug for Array

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

Formats the value using the given formatter.

impl Default for Array

fn default() -> Self

Returns the “default value” for a type.

impl From<Value> for Array

fn from(value: Value) -> Self

Converts to this type from the input type.

impl FromIterator<AnyObject> for Array

Converts an iterator into Array.

Examples

use rutie::{Array, Fixnum, Object, VM};

let array: Array = (1..6)
    .map(|num| num * 2)
    .map(|num| Fixnum::new(num).to_any_object())
    .collect();

assert_eq!(array.length(), 5);

for i in 0..5 {
    let expected_number = (i + 1) * 2;

    assert_eq!(array.at(i).try_convert_to::<Fixnum>().unwrap().to_i64(), expected_number);
}

fn from_iter<I: IntoIterator<Item = AnyObject>>(iter: I) -> Self

Creates a value from an iterator.

impl Into<AnyObject> for Array

fn into(self) -> AnyObject

Converts this type into the (usually inferred) input type.

impl Into<Value> for Array

fn into(self) -> Value

Converts this type into the (usually inferred) input type.

impl IntoIterator for Array

Allows Arrays to be iterable in Rust.

Examples

use rutie::{Array, Fixnum, Object, VM};

let mut array = Array::new()
    .push(Fixnum::new(1))
    .push(Fixnum::new(2))
    .push(Fixnum::new(3));

let mut sum: i64 = 0;

for item in array.into_iter() {
    sum += item.try_convert_to::<Fixnum>().unwrap().to_i64();
}

assert_eq!(sum, 6);

type Item = AnyObject

The type of the elements being iterated over.

type IntoIter = ArrayIterator

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl Object for Array

fn value(&self) -> Value

Returns internal value of current object.

fn class(&self) -> Class

Returns a class of current object.

fn singleton_class(&self) -> Class

Returns a singleton class of current object.

fn get_data<'a, T>(&'a self, wrapper: &'a dyn DataTypeWrapper<T>) -> &T

Gets an immutable reference to the Rust structure which is wrapped into a Ruby object.

fn get_data_mut<'a, T>( &'a mut self, wrapper: &'a dyn DataTypeWrapper<T> ) -> &mut T

Gets a mutable reference to the Rust structure which is wrapped into a Ruby object.

fn define<F: Fn(&mut Self)>(&mut self, f: F) -> &Self

Wraps calls to the object.

fn define_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines an instance method for the given class or object.

fn define_private_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a private instance method for the given class or object.

fn define_singleton_method<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

Defines a class method for given class or singleton method for object.

fn def<I: Object, O: Object>(&mut self, name: &str, callback: Callback<I, O>)

An alias for define_method (similar to Ruby syntax def some_method).

fn def_private<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_private_method (similar to Ruby syntax private def some_method).

fn def_self<I: Object, O: Object>( &mut self, name: &str, callback: Callback<I, O> )

An alias for define_singleton_method (similar to Ruby def self.some_method).

unsafe fn send(&self, method: &str, arguments: &[AnyObject]) -> AnyObject

Calls a given method on an object similarly to Ruby Object#send method

fn equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ==

fn case_equals<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s ===

fn is_eql<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s eql?

fn is_equal<T: Object>(&self, other: &T) -> bool

Alias for Ruby’s equal?

fn respond_to(&self, method: &str) -> bool

Checks whether the object responds to given method

fn protect_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_send returns Result<AnyObject, AnyObject>

fn protect_public_send( &self, method: &str, arguments: &[AnyObject] ) -> Result<AnyObject, AnyException>

protect_public_send returns Result<AnyObject, AnyObject>

fn is_nil(&self) -> bool

Checks whether the object is nil

fn to_any_object(&self) -> AnyObject

Converts struct to AnyObject

fn instance_variable_get(&self, variable: &str) -> AnyObject

Gets an instance variable of object

fn instance_variable_set<T: Object>( &mut self, variable: &str, value: T ) -> AnyObject

Sets an instance variable for object

fn is_frozen(&self) -> bool

Returns the freeze status of the object.

fn freeze(&mut self) -> Self

Prevents further modifications to the object.

unsafe fn to<T: Object>(&self) -> T

Unsafely casts current object to the specified Ruby type

fn try_convert_to<T: VerifiedObject>(&self) -> Result<T, AnyException>

Safely casts current object to the specified Ruby type

fn ty(&self) -> ValueType

Determines the value type of the object

impl PartialEq for Array

fn eq(&self, other: &Self) -> 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.

impl VerifiedObject for Array

fn is_correct_type<T: Object>(object: &T) -> bool

fn error_message() -> &'static str