/*
* call-seq:
* lmc.get(key) -> string value or nil
* lmc[key] -> string value or nil
*
* Retrieve string value from hashtable.
*/
static VALUE LocalMemCache__get(VALUE obj, VALUE key) {
size_t l;
lmc_rb_str_d_t k;
rstring_acquire(key, &k);
const char* r = __local_memcache_get(get_LocalMemCache(obj),
k.cstr, k.len, &l);
VALUE rr = lmc_ruby_string2(r, l);
lmc_unlock_shm_region("local_memcache_get", get_LocalMemCache(obj));
return rr;
}
/*
* call-seq:
* lmc.each_pair {|k, v| block } -> nil
*
* Iterates over hashtable.
*/
static VALUE LocalMemCache__each_pair(VALUE obj) {
VALUE d = rb_ary_new();
rb_ary_push(d, obj);
int error = 0;
rb_protect(__LocalMemCache__each_pair, d, &error);
if (error) {
lmc_unlock_shm_region("local_memcache_iterate", get_LocalMemCache(obj));
rb_exc_raise(ruby_errinfo);
}
return Qnil;
}
/*
* call-seq:
* lmc.get(key) -> string value or nil
* lmc[key] -> string value or nil
*
* Retrieve string value from hashtable.
*/
static mrb_value Cache__get(mrb_state *mrb, mrb_value self)
{
local_memcache_t *lmc = get_Cache(mrb, self);
size_t l;
char *key;
mrb_int n_key;
mrb_get_args(mrb, "s", &key, &n_key);
const char *r = __local_memcache_get(lmc, key, n_key, &l);
mrb_value rr = lmc_ruby_string2(mrb, r, l);
lmc_unlock_shm_region("local_memcache_get", lmc);
return rr;
}
/*
* call-seq:
* lmc.random_pair() -> [key, value] or nil
*
* Retrieves random pair from hashtable.
*/
static VALUE LocalMemCache__random_pair(VALUE obj) {
char *k, *v;
size_t n_k, n_v;
VALUE r = Qnil;
if (__local_memcache_random_pair(get_LocalMemCache(obj), &k, &n_k, &v,
&n_v)) {
r = rb_ary_new();
rb_ary_push(r, lmc_ruby_string2(k, n_k));
rb_ary_push(r, lmc_ruby_string2(v, n_v));
}
lmc_unlock_shm_region("local_memcache_random_pair",
get_LocalMemCache(obj));
return r;
}
static mrb_value Cache__shm_status(mrb_state *mrb, mrb_value self)
{
mrb_value hash = mrb_hash_new(mrb);
local_memcache_t *lmc = get_Cache(mrb, self);
if (!lmc_lock_shm_region("shm_status", lmc))
return mrb_nil_value();
lmc_mem_status_t ms = lmc_status(lmc->base, "shm_status");
if (!lmc_unlock_shm_region("shm_status", lmc))
return mrb_nil_value();
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "free_bytes")), mrb_fixnum_value(ms.total_free_mem));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "total_bytes")), mrb_fixnum_value(ms.total_shm_size));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "used_bytes")),
mrb_fixnum_value(ms.total_shm_size - ms.total_free_mem));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "free_chunks")), mrb_fixnum_value(ms.free_chunks));
mrb_hash_set(mrb, hash, mrb_symbol_value(mrb_intern_cstr(mrb, "largest_chunk")), mrb_fixnum_value(ms.largest_chunk));
return hash;
}
/*
* call-seq:
* lmc.shm_status -> hash
*
* Some status information on the shared memory:
*
* :total_bytes # the total size of the shm in bytes
* :used_bytes # how many bytes are used in this shm
* # For exmpty namespaces this will reflect the amount
* # of memory used for the hash buckets and some other
* # administrative data structures.
* :free_bytes # how many bytes are free
*/
static VALUE LocalMemCache__shm_status(VALUE obj) {
VALUE hash = rb_hash_new();
local_memcache_t *lmc = get_LocalMemCache(obj);
if (!lmc_lock_shm_region("shm_status", lmc)) return Qnil;
lmc_mem_status_t ms = lmc_status(lmc->base, "shm_status");
if (!lmc_unlock_shm_region("shm_status", lmc)) return Qnil;
rb_hash_aset(hash, ID2SYM(rb_intern("free_bytes")),
rb_int2big(ms.total_free_mem));
rb_hash_aset(hash, ID2SYM(rb_intern("total_bytes")),
rb_int2big(ms.total_shm_size));
rb_hash_aset(hash, ID2SYM(rb_intern("used_bytes")), rb_int2big(
ms.total_shm_size - ms.total_free_mem));
rb_hash_aset(hash, ID2SYM(rb_intern("free_chunks")), rb_int2big(
ms.free_chunks));
rb_hash_aset(hash, ID2SYM(rb_intern("largest_chunk")), rb_int2big(
ms.largest_chunk));
return hash;
}
