Struct rutie::Hash

pub struct Hash { /* fields omitted */ }

Hash

Implementations

impl Hash

pub fn new() -> Self

Creates a new instance of empty Hash.

Examples

use rutie::{Hash, VM};

Hash::new();

Ruby:

{}

pub fn at<T: Object>(&self, key: &T) -> AnyObject

Retrieves an AnyObject from element stored at key key.

Examples

use rutie::{Fixnum, Hash, Object, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("key"), Fixnum::new(1));

assert_eq!(hash.at(&Symbol::new("key")).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

hash = {}
hash[:key] = 1

hash[:key] == 1

pub fn store<K: Object, V: Object>(&mut self, key: K, value: V) -> AnyObject

Associates the value with the key.

Both key and value must be types which implement Object trait.

Examples

use rutie::{Fixnum, Hash, Object, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("key"), Fixnum::new(1));

assert_eq!(hash.at(&Symbol::new("key")).try_convert_to::<Fixnum>(), Ok(Fixnum::new(1)));

Ruby:

hash = {}
hash[:key] = 1

hash[:key] == 1

pub fn length(&self) -> usize

Retrieves the length of the hash.

Examples

use rutie::{Hash, Fixnum, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("key1"), Fixnum::new(1));
assert_eq!(hash.length(), 1);

hash.store(Symbol::new("key2"), Fixnum::new(2));
assert_eq!(hash.length(), 2);

Ruby:

hash = {}

hash[:key1] = 1
hash.length == 1

hash[:key2] = 2
hash.length == 2

pub fn clear(&self)

Removes all key-value pairs.

Examples

use rutie::{Hash, Fixnum, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("key1"), Fixnum::new(1));
hash.store(Symbol::new("key2"), Fixnum::new(2));
assert_eq!(hash.length(), 2);

hash.clear();
assert_eq!(hash.length(), 0);

Ruby:

hash = {}

hash[:key1] = 1
hash[:key2] = 2
hash.length == 2

hash.clear

hash.length == 0

pub fn delete<K: Object>(&mut self, key: K) -> AnyObject

Deletes the key-value pair and returns the value from hash whose key is equal to key. If the key is not found, it returns nil.

key must be a type which implements the Object trait.

Examples

use rutie::{Fixnum, Hash, Object, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("key1"), Fixnum::new(1));
hash.store(Symbol::new("key2"), Fixnum::new(2));
assert_eq!(hash.length(), 2);

let deleted = hash.delete(Symbol::new("key2"));
assert_eq!(hash.length(), 1);
assert_eq!(deleted.try_convert_to::<Fixnum>(), Ok(Fixnum::new(2)));

Ruby:

hash = {}

hash[:key1] = 1
hash[:key2] = 2
hash.length == 2

deleted = hash.delete(:key2)

hash.length == 1
deleted == 2

pub fn each<F>(&self, closure: F) where
    F: FnMut(AnyObject, AnyObject), 

Runs a closure for each key and value pair.

Key and value have AnyObject type.

Examples

use rutie::{Fixnum, Hash, Object, Symbol, VM};

let mut hash = Hash::new();

hash.store(Symbol::new("first_key"), Fixnum::new(1));
hash.store(Symbol::new("second_key"), Fixnum::new(2));

let mut doubled_values: Vec<i64> = Vec::new();

hash.each(|_key, value| {
    if let Ok(value) = value.try_convert_to::<Fixnum>() {
        doubled_values.push(value.to_i64() * 2);
    }
});

assert_eq!(doubled_values, vec![2, 4]);

Ruby:

hash = {
  first_key: 1,
  second_key: 2
}

doubled_values = []

hash.each do |_key, value|
  doubled_values << [value * 2]
end

doubled_values == [2, 4]

Trait Implementations

impl Clone for Hash

fn clone(&self) -> Hash

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Hash

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

Formats the value using the given formatter.

impl Default for Hash

fn default() -> Self

Returns the "default value" for a type.

impl From<Value> for Hash

fn from(value: Value) -> Self

Performs the conversion.

impl Into<AnyObject> for Hash

fn into(self) -> AnyObject

Performs the conversion.

impl Into<Value> for Hash

fn into(self) -> Value

Performs the conversion.

impl Object for Hash

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<Hash> for Hash

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl VerifiedObject for Hash

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

fn error_message() -> &'static str