Class: SparseArray

Inherits:

Object

• Object
• SparseArray

Includes:

Enumerable

Defined in:

lib/sparse_array/version.rb,
ext/sp_ar.c

Constant Summary

VERSION =

"0.0.5"

Instance Method Summary

• #[](ri) ⇒ Object
• #[]=(ri, val) ⇒ Object
• #clear ⇒ Object
• #count ⇒ Object
• #delete(ri) ⇒ Object
• #each ⇒ Object
• #each_key ⇒ Object
• #each_pair ⇒ Object
• #each_value ⇒ Object
• #empty? ⇒ Boolean
• #fetch(ri, def) ⇒ Object
• #has_key?(ri) ⇒ Boolean
• #include?(ri) ⇒ Boolean
• #initialize_copy(copy) ⇒ Object
• #inspect ⇒ Object
• #keys ⇒ Object
• #size ⇒ Object
• #values ⇒ Object

Instance Method Details

#[](ri) ⇒ Object

# File 'ext/sp_ar.c', line 416

static VALUE
sparse_array_get(VALUE self, VALUE ri)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    st_data_t res = Qnil;
    GetSparseArray(self, table);
    spar_lookup(table, i, &res);
    return (VALUE)res;
}

#[]=(ri, val) ⇒ Object

# File 'ext/sp_ar.c', line 453

static VALUE
sparse_array_set(VALUE self, VALUE ri, VALUE val)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    GetSparseArray(self, table);
    spar_insert(table, i, val);
    return val;
}

#clear ⇒ Object

# File 'ext/sp_ar.c', line 491

static VALUE
sparse_array_clear(VALUE self)
{
    spar_table *table;
    GetSparseArray(self, table);
    spar_clear(table);
    return self;
}

#count ⇒ Object

# File 'ext/sp_ar.c', line 475

static VALUE
sparse_array_size(VALUE self)
{
    spar_table *table;
    GetSparseArray(self, table);
    return UINT2NUM(table->num_entries);
}

#delete(ri) ⇒ Object

# File 'ext/sp_ar.c', line 463

static VALUE
sparse_array_del(VALUE self, VALUE ri)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    st_data_t res = Qnil;
    GetSparseArray(self, table);
    if (spar_delete(table, i, &res))
        return (VALUE)res;
    return Qnil;
}

#each ⇒ Object

# File 'ext/sp_ar.c', line 527

static VALUE
sparse_array_each(VALUE self)
{
    spar_table *table;
    VALUE y[2] = {Qnil, Qnil};
    RETURN_ENUMERATOR(self, 0, 0);
    GetSparseArray(self, table);
    SPAR_FOREACH_START(table);
    y[0] = UINT2NUM(entry->key);
    y[1] = (VALUE)value;
    rb_yield_values2(2, y);
    SPAR_FOREACH_END();
    return self;
}

#each_key ⇒ Object

# File 'ext/sp_ar.c', line 542

static VALUE
sparse_array_each_key(VALUE self)
{
    spar_table *table;
    RETURN_ENUMERATOR(self, 0, 0);
    GetSparseArray(self, table);
    SPAR_FOREACH_START(table);
    (void)value;
    rb_yield(UINT2NUM(entry->key));
    SPAR_FOREACH_END();
    return self;
}

#each_pair ⇒ Object

# File 'ext/sp_ar.c', line 527

static VALUE
sparse_array_each(VALUE self)
{
    spar_table *table;
    VALUE y[2] = {Qnil, Qnil};
    RETURN_ENUMERATOR(self, 0, 0);
    GetSparseArray(self, table);
    SPAR_FOREACH_START(table);
    y[0] = UINT2NUM(entry->key);
    y[1] = (VALUE)value;
    rb_yield_values2(2, y);
    SPAR_FOREACH_END();
    return self;
}

#each_value ⇒ Object

# File 'ext/sp_ar.c', line 555

static VALUE
sparse_array_each_value(VALUE self)
{
    spar_table *table;
    RETURN_ENUMERATOR(self, 0, 0);
    GetSparseArrayInt(self, table);
    SPAR_FOREACH_START(table);
    rb_yield((VALUE)(value));
    SPAR_FOREACH_END();
    return self;
}

#empty? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/sp_ar.c', line 483

static VALUE
sparse_array_empty_p(VALUE self)
{
    spar_table *table;
    GetSparseArray(self, table);
    return table->num_entries ? Qfalse : Qtrue;
}

#fetch(ri, def) ⇒ Object

# File 'ext/sp_ar.c', line 440

static VALUE
sparse_array_fetch(VALUE self, VALUE ri, VALUE def)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    st_data_t res = Qnil;
    GetSparseArray(self, table);
    if (spar_lookup(table, i, &res))
        return (VALUE)res;
    else
        return def;
}

#has_key?(ri) ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/sp_ar.c', line 427

static VALUE
sparse_array_include(VALUE self, VALUE ri)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    st_data_t res = Qnil;
    GetSparseArray(self, table);
    if (spar_lookup(table, i, &res))
        return Qtrue;
    else
        return Qfalse;
}

#include?(ri) ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/sp_ar.c', line 427

static VALUE
sparse_array_include(VALUE self, VALUE ri)
{
    spar_table *table;
    spar_index_t i = NUM2UINT(ri);
    st_data_t res = Qnil;
    GetSparseArray(self, table);
    if (spar_lookup(table, i, &res))
        return Qtrue;
    else
        return Qfalse;
}

#initialize_copy(copy) ⇒ Object

# File 'ext/sp_ar.c', line 567

static VALUE
sparse_array_init_copy(VALUE self, VALUE copy)
{
    spar_table *table;
    spar_table *copied;
    GetSparseArray(self, table);
    GetSparseArray(copy, copied);
    rb_obj_init_copy(self, copy);
    spar_copy_to(table, copied);
    return copy;
}

#inspect ⇒ Object

# File 'ext/sp_ar.c', line 600

static VALUE
sparse_array_inspect(VALUE self)
{
    spar_table *table;
    GetSparseArray(self, table);
    if (table->num_entries == 0)
        return rb_usascii_str_new2("<SparseArray>");
    return rb_exec_recursive(sparse_array_inspect_rec, self, 0);
}

#keys ⇒ Object

# File 'ext/sp_ar.c', line 500

static VALUE
sparse_array_keys(VALUE self)
{
    spar_table *table;
    VALUE res;
    GetSparseArray(self, table);
    res = rb_ary_new2(table->num_entries);
    SPAR_FOREACH_START(table);
    (void)value;
    rb_ary_push(res, UINT2NUM(entry->key));
    SPAR_FOREACH_END();
    return res;
}

#size ⇒ Object

# File 'ext/sp_ar.c', line 475

static VALUE
sparse_array_size(VALUE self)
{
    spar_table *table;
    GetSparseArray(self, table);
    return UINT2NUM(table->num_entries);
}

#values ⇒ Object

# File 'ext/sp_ar.c', line 514

static VALUE
sparse_array_values(VALUE self)
{
    spar_table *table;
    VALUE res;
    GetSparseArray(self, table);
    res = rb_ary_new2(table->num_entries);
    SPAR_FOREACH_START(table);
    rb_ary_push(res, (VALUE)value);
    SPAR_FOREACH_END();
    return res;
}