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.
#[]=(key, value)

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?	Returns whether every element meets a given criterion.
#any?	Returns whether any element meets a given criterion.
#chain	Returns an enumerator object generated from this enumerator and given enumerables.
#chunk	Each element in the returned enumerator is a 2-element array consisting of:
#chunk_while	Creates an enumerator for each chunked elements.
#collect	Alias for Enumerable#map.
#collect_concat	Alias for Enumerable#flat_map.
#compact	Returns an array of all non-`nil` elements:
#count	Returns the count of elements, based on an argument or block criterion, if given.
#cycle	When called with positive integer argument `n` and a block, calls the block with each element, then does so again, until it has done so `n` times; returns `nil`:
#detect	Alias for Enumerable#find.
#drop	For positive integer `n`, returns an array containing all but the first `n` elements:
#drop_while	Calls the block with successive elements as long as the block returns a truthy value; returns an array of all elements after that point:
#each_cons	Calls the block with each successive overlapped `n`-tuple of elements; returns `self`:
#each_entry	Calls the given block with each element, converting multiple values from yield to an array; returns `self`:
#each_slice	Calls the block with each successive disjoint `n`-tuple of elements; returns `self`:
#each_with_index	With a block given, calls the block with each element and its index; returns `self`:
#each_with_object	Calls the block once for each element, passing both the element and the given object:
#entries	Alias for Enumerable#to_a.
#filter	Returns an array containing elements selected by the block.
#filter_map	Returns an array containing truthy elements returned by the block.
#find	Returns the first element for which the block returns a truthy value.
#find_all	Alias for Enumerable#filter.
#find_index	Returns the index of the first element that meets a specified criterion, or `nil` if no such element is found.
#first	Returns the first element or elements.
#flat_map	Returns an array of flattened objects returned by the block.
#grep	Returns an array of objects based elements of `self` that match the given pattern.
#grep_v	Returns an array of objects based on elements of `self` that don’t match the given pattern.
#group_by	With a block given returns a hash:
#include?	Alias for Enumerable#member?.
#inject	Returns an object formed from operands via either:
#lazy	Returns an `::Enumerator::Lazy`, which redefines most `::Enumerable` methods to postpone enumeration and enumerate values only on an as-needed basis.
#map	Returns an array of objects returned by the block.
#max	Returns the element with the maximum element according to a given criterion.
#max_by	Returns the elements for which the block returns the maximum values.
#member?	Returns whether for any element `object == element`:
#min	Returns the element with the minimum element according to a given criterion.
#min_by	Returns the elements for which the block returns the minimum values.
#minmax	Returns a 2-element array containing the minimum and maximum elements according to a given criterion.
#minmax_by	Returns a 2-element array containing the elements for which the block returns minimum and maximum values:
#none?	Returns whether no element meets a given criterion.
#one?	Returns whether exactly one element meets a given criterion.
#partition	With a block given, returns an array of two arrays:
#reduce	Alias for Enumerable#inject.
#reject	Returns an array of objects rejected by the block.
#reverse_each	With a block given, calls the block with each element, but in reverse order; returns `self`:
#select	Alias for Enumerable#filter.
#slice_after	Creates an enumerator for each chunked elements.
#slice_before	With argument `pattern`, returns an enumerator that uses the pattern to partition elements into arrays (“slices”).
#slice_when	Creates an enumerator for each chunked elements.
#sort	Returns an array containing the sorted elements of `self`.
#sort_by	With a block given, returns an array of elements of `self`, sorted according to the value returned by the block for each element.
#sum	With no block given, returns the sum of `initial_value` and the elements:
#take	For non-negative integer `n`, returns the first `n` elements:
#take_while	Calls the block with successive elements as long as the block returns a truthy value; returns an array of all elements up to that point:
#tally	Returns a hash containing the counts of equal elements:
#to_a	Returns an array containing the items in `self`:
#to_h	When `self` consists of 2-element arrays, returns a hash each of whose entries is the key-value pair formed from one of those arrays:
#to_set	Makes a set from the enumerable object with given arguments.
#uniq	With no block, returns a new array containing only unique elements; the array has no two elements `e0` and `e1` such that `e0.eql?(e1)`:
#zip	With no block given, returns a new array `new_array` of size self.size whose elements are arrays.

Instance Method Details

#[](key)

Retrieves a weakly referenced object with the given key

[ GitHub ]

# File 'gc.c', line 13373


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

#[]=(key, value)

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

[ GitHub ]

# File 'gc.c', line 13320


static VALUE
wmap_aset(VALUE self, VALUE key, VALUE value)
{
    struct weakmap *w;

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

    struct wmap_aset_replace_args aset_args = {
        .new_value = value,
        .old_value = Qundef,
    };
    st_update(w->wmap2obj, (st_data_t)key, wmap_aset_replace_value, (st_data_t)&aset_args);

    // If the value is unchanged, we have nothing to do.
    if (value != aset_args.old_value) {
        if (!UNDEF_P(aset_args.old_value) && FL_ABLE(aset_args.old_value)) {
            // That key existed and had an inverse reference, we need to clear the outdated inverse reference.
            st_update(w->obj2wmap, (st_data_t)aset_args.old_value, wmap_remove_inverse_ref, key);
        }

        if (FL_ABLE(value)) {
            // If the value has no finalizer, we don't need to keep the inverse reference
            st_update(w->obj2wmap, (st_data_t)value, wmap_aset_update, key);
        }
    }

    return nonspecial_obj_id(value);
}

#each Also known as: #each_pair

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 13150


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 13176


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 13202


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 13109


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 13381


static VALUE
wmap_has_key(VALUE self, VALUE key)
{
    return RBOOL(!UNDEF_P(wmap_lookup(self, key)));
}

#keys

Iterates over keys and objects in a weakly referenced object

[ GitHub ]

# File 'gc.c', line 13230


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 13388


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 13260


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)

#[]=(key, value)

#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`