Class: ObjectSpace::WeakMap (Ruby 2.3.4)

    In Files

    • gc.c

    Class/Module Index [+]

    Quicksearch

    ObjectSpace::WeakMap

    An ObjectSpace::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.

    Public Instance Methods

    [](p1) click to toggle source

    Retrieves a weakly referenced object with the given key

     
                   static VALUE
    wmap_aref(VALUE self, VALUE wmap)
    {
        st_data_t data;
        VALUE obj;
        struct weakmap *w;
        rb_objspace_t *objspace = &rb_objspace;
    
        TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
        if (!st_lookup(w->wmap2obj, (st_data_t)wmap, &data)) return Qnil;
        obj = (VALUE)data;
        if (!is_id_value(objspace, obj)) return Qnil;
        if (!is_live_object(objspace, obj)) return Qnil;
        return obj;
    }
                
    []=(p1, p2) click to toggle source

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

     
                   static VALUE
    wmap_aset(VALUE self, VALUE wmap, VALUE orig)
    {
        struct weakmap *w;
    
        TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
        should_be_finalizable(orig);
        should_be_finalizable(wmap);
        define_final0(orig, w->final);
        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() click to toggle source

    Iterates over keys and objects in a weakly referenced object

     
                   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() click to toggle source

    Iterates over keys and objects in a weakly referenced object

     
                   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() click to toggle source

    Iterates over keys and objects in a weakly referenced object

     
                   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_value() click to toggle source

    Iterates over keys and objects in a weakly referenced object

     
                   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?(p1) click to toggle source

    Returns true if key is registered

     
                   static VALUE
    wmap_has_key(VALUE self, VALUE key)
    {
        return NIL_P(wmap_aref(self, key)) ? Qfalse : Qtrue;
    }
                
    inspect() click to toggle source
     
                   static VALUE
    wmap_inspect(VALUE self)
    {
        VALUE str;
        VALUE c = rb_class_name(CLASS_OF(self));
        struct weakmap *w;
    
        TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
        str = rb_sprintf("-<%"PRIsVALUE":%p", c, (void *)self);
        if (w->wmap2obj) {
            st_foreach(w->wmap2obj, wmap_inspect_i, str);
        }
        RSTRING_PTR(str)[0] = '#';
        rb_str_cat2(str, ">");
        return str;
    }
                
    key?(p1) click to toggle source

    Returns true if key is registered

     
                   static VALUE
    wmap_has_key(VALUE self, VALUE key)
    {
        return NIL_P(wmap_aref(self, key)) ? Qfalse : Qtrue;
    }
                
    keys() click to toggle source

    Iterates over keys and objects in a weakly referenced object

     
                   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() click to toggle source
     
                   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?(p1) click to toggle source

    Returns true if key is registered

     
                   static VALUE
    wmap_has_key(VALUE self, VALUE key)
    {
        return NIL_P(wmap_aref(self, key)) ? Qfalse : Qtrue;
    }
                
    size() click to toggle source
     
                   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
    }
                
    values() click to toggle source

    Iterates over values and objects in a weakly referenced object

     
                   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;
    }
                

    Private Instance Methods

    finalize(p1) click to toggle source
     
                   static VALUE
    wmap_finalize(VALUE self, VALUE objid)
    {
        st_data_t orig, wmap, data;
        VALUE obj, *rids, i, size;
        struct weakmap *w;
    
        TypedData_Get_Struct(self, struct weakmap, &weakmap_type, w);
        /* Get reference from object id. */
        obj = obj_id_to_ref(objid);
    
        /* obj is original referenced object and/or weak reference. */
        orig = (st_data_t)obj;
        if (st_delete(w->obj2wmap, &orig, &data)) {
            rids = (VALUE *)data;
            size = *rids++;
            for (i = 0; i < size; ++i) {
                wmap = (st_data_t)rids[i];
                st_delete(w->wmap2obj, &wmap, NULL);
            }
            ruby_sized_xfree((VALUE *)data, (size + 1) * sizeof(VALUE));
        }
    
        wmap = (st_data_t)obj;
        if (st_delete(w->wmap2obj, &wmap, &orig)) {
            wmap = (st_data_t)obj;
            st_update(w->obj2wmap, orig, wmap_final_func, wmap);
        }
        return self;
    }