Class: ObjectSpace::WeakMap

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Instance Chain: self, `::Enumerable`
Inherits:	Object
Defined in:	gc.c, gc.c

Overview

An WeakMap object holds references to any objects, but those objects can get garbage collected.

This class is mostly used internally by WeakRef, please use lib/weakref.rb for the public interface.

Instance Method Summary

#[](key)

Retrieves a weakly referenced object with the given key.
#[]=(wmap, orig)

Creates a weak reference from the given key to the given value.
#each (also: #each_pair)

Iterates over keys and objects in a weakly referenced object.
#each_key

Iterates over keys and objects in a weakly referenced object.
#each_pair

Alias for #each.
#each_value

Iterates over keys and objects in a weakly referenced object.
#include?(key) ⇒ Boolean

Alias for #key?.
#inspect
#key?(key) (also: #include?, #member?)

Returns true if key is registered.
#keys

Iterates over keys and objects in a weakly referenced object.
#length (also: #size)

Returns the number of referenced objects.
#member?(key) ⇒ Boolean

Alias for #key?.
#size

Alias for #length.
#values

Iterates over values and objects in a weakly referenced object.

`::Enumerable` - Included

#all?	Passes each element of the collection to the given block.
#any?	Passes each element of the collection to the given block.
#chain	Returns an enumerator object generated from this enumerator and given enumerables.
#chunk	Enumerates over the items, chunking them together based on the return value of the block.
#chunk_while	Creates an enumerator for each chunked elements.
#collect	Alias for Enumerable#map.
#collect_concat	Alias for Enumerable#flat_map.
#count	Returns the number of items in `enum` through enumeration.
#cycle	Calls block for each element of enum repeatedly n times or forever if none or `nil` is given.
#detect	Alias for Enumerable#find.
#drop	Drops first n elements from enum, and returns rest elements in an array.
#drop_while	Drops elements up to, but not including, the first element for which the block returns `nil` or `false` and returns an array containing the remaining elements.
#each_cons	Iterates the given block for each array of consecutive <n> elements.
#each_entry	Calls block once for each element in `self`, passing that element as a parameter, converting multiple values from yield to an array.
#each_slice	Iterates the given block for each slice of <n> elements.
#each_with_index	Calls block with two arguments, the item and its index, for each item in enum.
#each_with_object	Iterates the given block for each element with an arbitrary object given, and returns the initially given object.
#entries	Alias for Enumerable#to_a.
#filter	Returns an array containing all elements of `enum` for which the given `block` returns a true value.
#filter_map	Returns a new array containing the truthy results (everything except `false` or `nil`) of running the `block` for every element in `enum`.
#find	Passes each entry in enum to block.
#find_all	Alias for Enumerable#filter.
#find_index	Compares each entry in enum with value or passes to block.
#first	Returns the first element, or the first `n` elements, of the enumerable.
#flat_map	Returns a new array with the concatenated results of running block once for every element in enum.
#grep	Returns an array of every element in enum for which `Pattern === element`.
#grep_v	Inverted version of Enumerable#grep.
#group_by	Groups the collection by result of the block.
#include?	Alias for Enumerable#member?.
#inject	Combines all elements of enum by applying a binary operation, specified by a block or a symbol that names a method or operator.
#lazy	Returns an `::Enumerator::Lazy`, which redefines most `::Enumerable` methods to postpone enumeration and enumerate values only on an as-needed basis.
#map	Returns a new array with the results of running block once for every element in enum.
#max	Returns the object in enum with the maximum value.
#max_by	Returns the object in enum that gives the maximum value from the given block.
#member?	Returns `true` if any member of enum equals obj.
#min	Returns the object in enum with the minimum value.
#min_by	Returns the object in enum that gives the minimum value from the given block.
#minmax	Returns a two element array which contains the minimum and the maximum value in the enumerable.
#minmax_by	Returns a two element array containing the objects in enum that correspond to the minimum and maximum values respectively from the given block.
#none?	Passes each element of the collection to the given block.
#one?	Passes each element of the collection to the given block.
#partition	Returns two arrays, the first containing the elements of enum for which the block evaluates to true, the second containing the rest.
#reduce	Alias for Enumerable#inject.
#reject	Returns an array for all elements of `enum` for which the given `block` returns `false`.
#reverse_each	Builds a temporary array and traverses that array in reverse order.
#select	Alias for Enumerable#filter.
#slice_after	Creates an enumerator for each chunked elements.
#slice_before	Creates an enumerator for each chunked elements.
#slice_when	Creates an enumerator for each chunked elements.
#sort	Returns an array containing the items in enum sorted.
#sort_by	Sorts enum using a set of keys generated by mapping the values in enum through the given block.
#sum	Returns the sum of elements in an `::Enumerable`.
#take	Returns first n elements from enum.
#take_while	Passes elements to the block until the block returns `nil` or `false`, then stops iterating and returns an array of all prior elements.
#tally	Tallies the collection, i.e., counts the occurrences of each element.
#to_a	Returns an array containing the items in enum.
#to_h	Returns the result of interpreting enum as a list of `[key, value]` pairs.
#uniq	Returns a new array by removing duplicate values in `self`.
#zip	Takes one element from enum and merges corresponding elements from each args.

Instance Method Details

#[](key)

Retrieves a weakly referenced object with the given key

[ GitHub ]

# File 'gc.c', line 10755


static VALUE
wmap_aref(VALUE self, VALUE key)
{
    VALUE obj = wmap_lookup(self, key);
    return obj != Qundef ? obj : Qnil;
}

#[]=(wmap, orig)

Creates a weak reference from the given key to the given value

[ GitHub ]

# File 'gc.c', line 10720


static VALUE
wmap_aset(VALUE self, VALUE wmap, VALUE orig)
{
    struct weakmap *w;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    if (FL_ABLE(orig)) {
        define_final0(orig, w->final);
    }
    if (FL_ABLE(wmap)) {
        define_final0(wmap, w->final);
    }

    st_update(w->obj2wmap, (st_data_t)orig, wmap_aset_update, wmap);
    st_insert(w->wmap2obj, (st_data_t)wmap, (st_data_t)orig);
    return nonspecial_obj_id(orig);
}

#each Also known as: #each_pair

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 10587


static VALUE
wmap_each(VALUE self)
{
    struct weakmap *w;
    rb_objspace_t *objspace = &rb_objspace;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    st_foreach(w->wmap2obj, wmap_each_i, (st_data_t)objspace);
    return self;
}

#each_key

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 10610


static VALUE
wmap_each_key(VALUE self)
{
    struct weakmap *w;
    rb_objspace_t *objspace = &rb_objspace;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    st_foreach(w->wmap2obj, wmap_each_key_i, (st_data_t)objspace);
    return self;
}

#each_pair

Alias for #each.

#each_value

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 10633


static VALUE
wmap_each_value(VALUE self)
{
    struct weakmap *w;
    rb_objspace_t *objspace = &rb_objspace;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    st_foreach(w->wmap2obj, wmap_each_value_i, (st_data_t)objspace);
    return self;
}

#include?(key) ⇒ `Boolean`

Alias for #key?.

#inspect

[ GitHub ]

# File 'gc.c', line 10555


static VALUE
wmap_inspect(VALUE self)
{
    VALUE str;
    VALUE c = rb_class_name(CLASS_OF(self));
    struct weakmap *w;
    struct wmap_iter_arg args;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void *)self);
    if (w->wmap2obj) {
	args.objspace = &rb_objspace;
	args.value = str;
	st_foreach(w->wmap2obj, wmap_inspect_i, (st_data_t)&args);
    }
    RSTRING_PTR(str)[0] = '#';
    rb_str_cat2(str, ">");
    return str;
}

#key?(key) Also known as: #include?, #member?

Returns true if key is registered

[ GitHub ]

# File 'gc.c', line 10763


static VALUE
wmap_has_key(VALUE self, VALUE key)
{
    return wmap_lookup(self, key) == Qundef ? Qfalse : Qtrue;
}

#keys

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 10658


static VALUE
wmap_keys(VALUE self)
{
    struct weakmap *w;
    struct wmap_iter_arg args;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    args.objspace = &rb_objspace;
    args.value = rb_ary_new();
    st_foreach(w->wmap2obj, wmap_keys_i, (st_data_t)&args);
    return args.value;
}

#length Also known as: #size

Returns the number of referenced objects

[ GitHub ]

# File 'gc.c', line 10770


static VALUE
wmap_size(VALUE self)
{
    struct weakmap *w;
    st_index_t n;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    n = w->wmap2obj->num_entries;
#if SIZEOF_ST_INDEX_T <= SIZEOF_LONG
    return ULONG2NUM(n);
#else
    return ULL2NUM(n);
#endif
}

#member?(key) ⇒ `Boolean`

Alias for #key?.

#size

Alias for #length.

#values

Iterates over values and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 10685


static VALUE
wmap_values(VALUE self)
{
    struct weakmap *w;
    struct wmap_iter_arg args;

    TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
    args.objspace = &rb_objspace;
    args.value = rb_ary_new();
    st_foreach(w->wmap2obj, wmap_values_i, (st_data_t)&args);
    return args.value;
}

Class: ObjectSpace::WeakMap

Overview

Instance Method Summary

::Enumerable - Included

Instance Method Details

#[](key)

#[]=(wmap, orig)

#each Also known as: #each_pair

#each_key

#each_pair

#each_value

#include?(key) ⇒ Boolean

#inspect

#key?(key) Also known as: #include?, #member?

#keys

#length Also known as: #size

#member?(key) ⇒ Boolean

#size

#values

`::Enumerable` - Included

#include?(key) ⇒ `Boolean`

#member?(key) ⇒ `Boolean`