Struct Hash

Source

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

Expand description

Hash

Implementations§

Source §

impl Hash

Source

pub fn new() -> Self

Creates a new instance of empty Hash.

§Examples

use rutie::{Hash, VM};

Hash::new();

Ruby:

{}

Source

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

Source

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

Source

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

Source

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

Source

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

Source

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]