/* :nodoc: */
static mrb_value Cache_init(mrb_state *mrb, mrb_value self)
{
  mrb_value o;
  mrb_get_args(mrb, "o", &o);
  lmc_check_dict(mrb, o);
  lmc_error_t e;
  rb_lmc_handle_t *h;

  local_memcache_t *l = local_memcache_create(rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_namespace(mrb))),
                                              rstring_ptr_null(mrb_hash_get(mrb, o, lmc_rb_sym_filename(mrb))),
                                              double_value(mrb, mrb_hash_get(mrb, o, lmc_rb_sym_size_mb(mrb))),
                                              size_t_value(mrb_hash_get(mrb, o, lmc_rb_sym_min_alloc_size(mrb))), &e);

  if (!l)
    rb_lmc_raise_exception(mrb, &e);

  h = (rb_lmc_handle_t *)DATA_PTR(self);
  if (h) {
    mrb_free(mrb, h);
  }
  DATA_TYPE(self) = &lmc_cache_type;
  DATA_PTR(self) = NULL;

  h = (rb_lmc_handle_t *)mrb_malloc(mrb, sizeof(rb_lmc_handle_t));
  if (!h) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "memory allocation error");
  }

  h->lmc = l;
  h->open = 1;

  DATA_PTR(self) = h;

  return self;
}
Exemple #2
0
int main() {
  lmc_error_t e;
  local_memcache_t *lmc = local_memcache_create("viewcounters", 0, 0, 0, &e);
  if (!lmc) {
    fprintf(stderr, "Couldn't create localmemcache: %s\n", e.error_str);
    return 1;
  }
  if (!local_memcache_set(lmc, "foo", 3, "1", 1)) goto failed;
  size_t n_value;
  char *value = local_memcache_get_new(lmc, "foo", 3, &n_value);
  if (!value) goto failed;
  free(value);
  if (!local_memcache_delete(lmc, "foo", 3)) goto failed;
  if (!local_memcache_free(lmc, &e)) {
    fprintf(stderr, "Failed to release localmemcache: %s\n", e.error_str);
    return 1;
  }

  return 0;

failed:
  fprintf(stderr, "%s\n", lmc->error.error_str);
  return 1;

}
/* :nodoc: */
static VALUE LocalMemCache__new2(VALUE klass, VALUE o) {
  lmc_check_dict(o);
  lmc_error_t e;
  local_memcache_t *l = local_memcache_create(
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_namespace)),
      rstring_ptr_null(rb_hash_aref(o, lmc_rb_sym_filename)), 
      double_value(rb_hash_aref(o, lmc_rb_sym_size_mb)),
      long_value(rb_hash_aref(o, lmc_rb_sym_min_alloc_size)), &e);
  if (!l)  rb_lmc_raise_exception(&e);
  rb_lmc_handle_t *h = calloc(1, sizeof(rb_lmc_handle_t));
  if (!h) rb_raise(rb_eRuntimeError, "memory allocation error");
  h->lmc = l;
  h->open = 1;
  return Data_Wrap_Struct(klass, NULL, rb_lmc_free_handle, h);
}