couchbase 1.2.0.z.beta4-x86-mingw32 → 1.2.0.z.beta5-x86-mingw32

data/ext/couchbase_ext/timer.c

@@ -26,7 +26,7 @@ cb_timer_free(void *ptr)
     void
 cb_timer_mark(void *ptr)
 {
-    struct timer_st *timer = ptr;
+    struct cb_timer_st *timer = ptr;
     if (timer) {
         rb_gc_mark(timer->callback);
     }
@@ -36,10 +36,10 @@ cb_timer_mark(void *ptr)
 cb_timer_alloc(VALUE klass)
 {
     VALUE obj;
-    struct timer_st *timer;
+    struct cb_timer_st *timer;
 
     /* allocate new bucket struct and set it to zero */
-    obj = Data_Make_Struct(klass, struct timer_st, cb_timer_mark,
+    obj = Data_Make_Struct(klass, struct cb_timer_st, cb_timer_mark,
             cb_timer_free, timer);
     return obj;
 }
@@ -56,7 +56,7 @@ cb_timer_alloc(VALUE klass)
 cb_timer_inspect(VALUE self)
 {
     VALUE str;
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     char buf[200];
 
     str = rb_str_buf_new2("#<");
@@ -97,7 +97,7 @@ cb_timer_inspect(VALUE self)
     VALUE
 cb_timer_cancel(VALUE self)
 {
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     lcb_timer_destroy(tm->bucket->handle, tm->timer);
     return self;
 }
@@ -105,7 +105,7 @@ cb_timer_cancel(VALUE self)
     static VALUE
 trigger_timer(VALUE timer)
 {
-    struct timer_st *tm = DATA_PTR(timer);
+    struct cb_timer_st *tm = DATA_PTR(timer);
     return cb_proc_call(tm->callback, 1, timer);
 }
 
@@ -113,7 +113,7 @@ trigger_timer(VALUE timer)
 timer_callback(lcb_timer_t timer, lcb_t instance,
         const void *cookie)
 {
-    struct timer_st *tm = (struct timer_st *)cookie;
+    struct cb_timer_st *tm = (struct cb_timer_st *)cookie;
     int error = 0;
 
     rb_protect(trigger_timer, tm->self, &error);
@@ -162,14 +162,14 @@ timer_callback(lcb_timer_t timer, lcb_t instance,
     VALUE
 cb_timer_init(int argc, VALUE *argv, VALUE self)
 {
-    struct timer_st *tm = DATA_PTR(self);
+    struct cb_timer_st *tm = DATA_PTR(self);
     VALUE bucket, opts, timeout, exc, cb;
     lcb_error_t err;
 
     rb_need_block();
     rb_scan_args(argc, argv, "21&", &bucket, &timeout, &opts, &cb);
 
-    if (CLASS_OF(bucket) != cBucket) {
+    if (CLASS_OF(bucket) != cb_cBucket) {
         rb_raise(rb_eTypeError, "wrong argument type (expected Couchbase::Bucket)");
     }
     tm->self = self;
@@ -178,7 +178,7 @@ cb_timer_init(int argc, VALUE *argv, VALUE self)
     tm->bucket = DATA_PTR(bucket);
     if (opts != Qnil) {
         Check_Type(opts, T_HASH);
-        tm->periodic = RTEST(rb_hash_aref(opts, sym_periodic));
+        tm->periodic = RTEST(rb_hash_aref(opts, cb_sym_periodic));
     }
     tm->timer = lcb_timer_create(tm->bucket->handle, tm, tm->usec,
             tm->periodic, timer_callback, &err);

data/ext/couchbase_ext/touch.c

@@ -18,20 +18,20 @@
 #include "couchbase_ext.h"
 
     void
-touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_touch_resp_t *resp)
+cb_touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_touch_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE key, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to touch value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_touch);
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_touch);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = cb_gc_protect(bucket, exc);
             }
@@ -40,10 +40,10 @@ touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_to
 
     if (bucket->async) {    /* asynchronous */
         if (ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, exc);
-            rb_ivar_set(res, id_iv_operation, sym_touch);
-            rb_ivar_set(res, id_iv_key, key);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, exc);
+            rb_ivar_set(res, cb_id_iv_operation, cb_sym_touch);
+            rb_ivar_set(res, cb_id_iv_key, key);
             cb_proc_call(ctx->proc, 1, res);
         }
     } else {                /* synchronous */
@@ -51,6 +51,9 @@ touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_to
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            xfree(ctx);
+        }
     }
     (void)handle;
 }
@@ -123,27 +126,27 @@ touch_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_to
    VALUE
 cb_bucket_touch(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_touch;
+    rb_funcall(args, cb_id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_touch;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = xcalloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->bucket = bucket;
@@ -162,7 +165,7 @@ cb_bucket_touch(int argc, VALUE *argv, VALUE self)
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {

data/ext/couchbase_ext/unlock.c

@@ -18,20 +18,20 @@
 #include "couchbase_ext.h"
 
     void
-unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp)
+cb_unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_unlock_resp_t *resp)
 {
-    struct context_st *ctx = (struct context_st *)cookie;
-    struct bucket_st *bucket = ctx->bucket;
+    struct cb_context_st *ctx = (struct cb_context_st *)cookie;
+    struct cb_bucket_st *bucket = ctx->bucket;
     VALUE key, *rv = ctx->rv, exc = Qnil, res;
 
     ctx->nqueries--;
     key = STR_NEW((const char*)resp->v.v0.key, resp->v.v0.nkey);
-    strip_key_prefix(bucket, key);
+    cb_strip_key_prefix(bucket, key);
 
     if (error != LCB_KEY_ENOENT || !ctx->quiet) {
         exc = cb_check_error(error, "failed to unlock value", key);
         if (exc != Qnil) {
-            rb_ivar_set(exc, id_iv_operation, sym_unlock);
+            rb_ivar_set(exc, cb_id_iv_operation, cb_sym_unlock);
             if (NIL_P(ctx->exception)) {
                 ctx->exception = cb_gc_protect(bucket, exc);
             }
@@ -40,10 +40,10 @@ unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_u
 
     if (bucket->async) {    /* asynchronous */
         if (ctx->proc != Qnil) {
-            res = rb_class_new_instance(0, NULL, cResult);
-            rb_ivar_set(res, id_iv_error, exc);
-            rb_ivar_set(res, id_iv_operation, sym_unlock);
-            rb_ivar_set(res, id_iv_key, key);
+            res = rb_class_new_instance(0, NULL, cb_cResult);
+            rb_ivar_set(res, cb_id_iv_error, exc);
+            rb_ivar_set(res, cb_id_iv_operation, cb_sym_unlock);
+            rb_ivar_set(res, cb_id_iv_key, key);
             cb_proc_call(ctx->proc, 1, res);
         }
     } else {                /* synchronous */
@@ -51,6 +51,9 @@ unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_u
     }
     if (ctx->nqueries == 0) {
         cb_gc_unprotect(bucket, ctx->proc);
+        if (bucket->async) {
+            xfree(ctx);
+        }
     }
     (void)handle;
 }
@@ -113,27 +116,27 @@ unlock_callback(lcb_t handle, const void *cookie, lcb_error_t error, const lcb_u
    VALUE
 cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
 {
-    struct bucket_st *bucket = DATA_PTR(self);
-    struct context_st *ctx;
+    struct cb_bucket_st *bucket = DATA_PTR(self);
+    struct cb_context_st *ctx;
     VALUE args, rv, proc, exc;
     lcb_error_t err;
-    struct params_st params;
+    struct cb_params_st params;
 
     if (bucket->handle == NULL) {
-        rb_raise(eConnectError, "closed connection");
+        rb_raise(cb_eConnectError, "closed connection");
     }
     rb_scan_args(argc, argv, "0*&", &args, &proc);
     if (!bucket->async && proc != Qnil) {
         rb_raise(rb_eArgError, "synchronous mode doesn't support callbacks");
     }
-    rb_funcall(args, id_flatten_bang, 0);
-    memset(&params, 0, sizeof(struct params_st));
-    params.type = cmd_unlock;
+    rb_funcall(args, cb_id_flatten_bang, 0);
+    memset(&params, 0, sizeof(struct cb_params_st));
+    params.type = cb_cmd_unlock;
     params.bucket = bucket;
     cb_params_build(&params, RARRAY_LEN(args), args);
-    ctx = xcalloc(1, sizeof(struct context_st));
+    ctx = xcalloc(1, sizeof(struct cb_context_st));
     if (ctx == NULL) {
-        rb_raise(eClientNoMemoryError, "failed to allocate memory for context");
+        rb_raise(cb_eClientNoMemoryError, "failed to allocate memory for context");
     }
     ctx->proc = cb_gc_protect(bucket, proc);
     ctx->bucket = bucket;
@@ -152,7 +155,7 @@ cb_bucket_unlock(int argc, VALUE *argv, VALUE self)
     }
     bucket->nbytes += params.npayload;
     if (bucket->async) {
-        maybe_do_loop(bucket);
+        cb_maybe_do_loop(bucket);
         return Qnil;
     } else {
         if (ctx->nqueries > 0) {

data/ext/couchbase_ext/utils.c

@@ -18,16 +18,16 @@
 #include "couchbase_ext.h"
 
     VALUE
-cb_gc_protect(struct bucket_st *bucket, VALUE val)
+cb_gc_protect(struct cb_bucket_st *bucket, VALUE val)
 {
     rb_hash_aset(bucket->object_space, val|1, val);
     return val;
 }
 
     VALUE
-cb_gc_unprotect(struct bucket_st *bucket, VALUE val)
+cb_gc_unprotect(struct cb_bucket_st *bucket, VALUE val)
 {
-    rb_funcall(bucket->object_space, id_delete, 1, val|1);
+    rb_funcall(bucket->object_space, cb_id_delete, 1, val|1);
     return val;
 }
 
@@ -39,7 +39,7 @@ cb_proc_call(VALUE recv, int argc, ...)
     int arity;
     int ii;
 
-    arity = FIX2INT(rb_funcall(recv, id_arity, 0));
+    arity = FIX2INT(rb_funcall(recv, cb_id_arity, 0));
     if (arity < 0) {
         arity = argc;
     }
@@ -57,13 +57,13 @@ cb_proc_call(VALUE recv, int argc, ...)
     } else {
         argv = NULL;
     }
-    return rb_funcall2(recv, id_call, arity, argv);
+    return rb_funcall2(recv, cb_id_call, arity, argv);
 }
 
 VALUE
 cb_hash_delete(VALUE hash, VALUE key)
 {
-    return rb_funcall(hash, id_delete, 1, key);
+    return rb_funcall(hash, cb_id_delete, 1, key);
 }
 
 /* Helper to convert return code from libcouchbase to meaningful exception.
@@ -83,87 +83,87 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     }
     switch (rc) {
         case LCB_AUTH_ERROR:
-            klass = eAuthError;
+            klass = cb_eAuthError;
             break;
         case LCB_DELTA_BADVAL:
-            klass = eDeltaBadvalError;
+            klass = cb_eDeltaBadvalError;
             break;
         case LCB_E2BIG:
-            klass = eTooBigError;
+            klass = cb_eTooBigError;
             break;
         case LCB_EBUSY:
-            klass = eBusyError;
+            klass = cb_eBusyError;
             break;
         case LCB_EINTERNAL:
-            klass = eInternalError;
+            klass = cb_eInternalError;
             break;
         case LCB_EINVAL:
-            klass = eInvalidError;
+            klass = cb_eInvalidError;
             break;
         case LCB_ENOMEM:
-            klass = eNoMemoryError;
+            klass = cb_eNoMemoryError;
             break;
         case LCB_ERANGE:
-            klass = eRangeError;
+            klass = cb_eRangeError;
             break;
         case LCB_ETMPFAIL:
-            klass = eTmpFailError;
+            klass = cb_eTmpFailError;
             break;
         case LCB_KEY_EEXISTS:
-            klass = eKeyExistsError;
+            klass = cb_eKeyExistsError;
             break;
         case LCB_KEY_ENOENT:
-            klass = eNotFoundError;
+            klass = cb_eNotFoundError;
             break;
         case LCB_DLOPEN_FAILED:
-            klass = eDlopenFailedError;
+            klass = cb_eDlopenFailedError;
             break;
         case LCB_DLSYM_FAILED:
-            klass = eDlsymFailedError;
+            klass = cb_eDlsymFailedError;
             break;
         case LCB_NETWORK_ERROR:
-            klass = eNetworkError;
+            klass = cb_eNetworkError;
             break;
         case LCB_NOT_MY_VBUCKET:
-            klass = eNotMyVbucketError;
+            klass = cb_eNotMyVbucketError;
             break;
         case LCB_NOT_STORED:
-            klass = eNotStoredError;
+            klass = cb_eNotStoredError;
             break;
         case LCB_NOT_SUPPORTED:
-            klass = eNotSupportedError;
+            klass = cb_eNotSupportedError;
             break;
         case LCB_UNKNOWN_COMMAND:
-            klass = eUnknownCommandError;
+            klass = cb_eUnknownCommandError;
             break;
         case LCB_UNKNOWN_HOST:
-            klass = eUnknownHostError;
+            klass = cb_eUnknownHostError;
             break;
         case LCB_PROTOCOL_ERROR:
-            klass = eProtocolError;
+            klass = cb_eProtocolError;
             break;
         case LCB_ETIMEDOUT:
-            klass = eTimeoutError;
+            klass = cb_eTimeoutError;
             break;
         case LCB_CONNECT_ERROR:
-            klass = eConnectError;
+            klass = cb_eConnectError;
             break;
         case LCB_BUCKET_ENOENT:
-            klass = eBucketNotFoundError;
+            klass = cb_eBucketNotFoundError;
             break;
         case LCB_CLIENT_ENOMEM:
-            klass = eClientNoMemoryError;
+            klass = cb_eClientNoMemoryError;
             break;
         case LCB_CLIENT_ETMPFAIL:
-            klass = eClientTmpFailError;
+            klass = cb_eClientTmpFailError;
             break;
         case LCB_EBADHANDLE:
-            klass = eBadHandleError;
+            klass = cb_eBadHandleError;
             break;
         case LCB_ERROR:
             /* fall through */
         default:
-            klass = eLibcouchbaseError;
+            klass = cb_eLibcouchbaseError;
     }
 
     str = rb_str_buf_new2(msg ? msg : "");
@@ -174,7 +174,7 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     }
     if (status > 0) {
         const char *reason = NULL;
-        klass = eHTTPError;
+        klass = cb_eHTTPError;
         snprintf(buf, 300, "status=\"%d\"", status);
         rb_str_buf_cat2(str, buf);
         switch (status) {
@@ -272,11 +272,11 @@ cb_check_error_with_status(lcb_error_t rc, const char *msg, VALUE key,
     snprintf(buf, 300, "error=0x%02x)", rc);
     rb_str_buf_cat2(str, buf);
     exc = rb_exc_new3(klass, str);
-    rb_ivar_set(exc, id_iv_error, INT2FIX(rc));
-    rb_ivar_set(exc, id_iv_key, key);
-    rb_ivar_set(exc, id_iv_cas, Qnil);
-    rb_ivar_set(exc, id_iv_operation, Qnil);
-    rb_ivar_set(exc, id_iv_status, status ? INT2FIX(status) : Qnil);
+    rb_ivar_set(exc, cb_id_iv_error, INT2FIX(rc));
+    rb_ivar_set(exc, cb_id_iv_key, key);
+    rb_ivar_set(exc, cb_id_iv_cas, Qnil);
+    rb_ivar_set(exc, cb_id_iv_operation, Qnil);
+    rb_ivar_set(exc, cb_id_iv_status, status ? INT2FIX(status) : Qnil);
     return exc;
 }
 
@@ -288,35 +288,35 @@ cb_check_error(lcb_error_t rc, const char *msg, VALUE key)
 
 
     uint32_t
-flags_set_format(uint32_t flags, ID format)
+cb_flags_set_format(uint32_t flags, ID format)
 {
-    flags &= ~((uint32_t)FMT_MASK); /* clear format bits */
-
-    if (format == sym_document) {
-        return flags | FMT_DOCUMENT;
-    } else if (format == sym_marshal) {
-        return flags | FMT_MARSHAL;
-    } else if (format == sym_plain) {
-        return flags | FMT_PLAIN;
+    flags &= ~((uint32_t)CB_FMT_MASK); /* clear format bits */
+
+    if (format == cb_sym_document) {
+        return flags | CB_FMT_DOCUMENT;
+    } else if (format == cb_sym_marshal) {
+        return flags | CB_FMT_MARSHAL;
+    } else if (format == cb_sym_plain) {
+        return flags | CB_FMT_PLAIN;
     }
     return flags; /* document is the default */
 }
 
     ID
-flags_get_format(uint32_t flags)
+cb_flags_get_format(uint32_t flags)
 {
-    flags &= FMT_MASK; /* select format bits */
+    flags &= CB_FMT_MASK; /* select format bits */
 
     switch (flags) {
-        case FMT_DOCUMENT:
-            return sym_document;
-        case FMT_MARSHAL:
-            return sym_marshal;
-        case FMT_PLAIN:
+        case CB_FMT_DOCUMENT:
+            return cb_sym_document;
+        case CB_FMT_MARSHAL:
+            return cb_sym_marshal;
+        case CB_FMT_PLAIN:
             /* fall through */
         default:
             /* all other formats treated as plain */
-            return sym_plain;
+            return cb_sym_plain;
     }
 }
 
@@ -325,14 +325,14 @@ flags_get_format(uint32_t flags)
 do_encode(VALUE *args)
 {
     VALUE val = args[0];
-    uint32_t flags = ((uint32_t)args[1] & FMT_MASK);
+    uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
 
     switch (flags) {
-        case FMT_DOCUMENT:
-            return rb_funcall(mMultiJson, id_dump, 1, val);
-        case FMT_MARSHAL:
-            return rb_funcall(mMarshal, id_dump, 1, val);
-        case FMT_PLAIN:
+        case CB_FMT_DOCUMENT:
+            return rb_funcall(cb_mMultiJson, cb_id_dump, 1, val);
+        case CB_FMT_MARSHAL:
+            return rb_funcall(cb_mMarshal, cb_id_dump, 1, val);
+        case CB_FMT_PLAIN:
             /* fall through */
         default:
             /* all other formats treated as plain */
@@ -347,22 +347,22 @@ do_decode(VALUE *args)
     VALUE force_format = args[2];
 
     if (TYPE(force_format) == T_SYMBOL) {
-        if (force_format == sym_document) {
-            return rb_funcall(mMultiJson, id_load, 1, blob);
-        } else if (force_format == sym_marshal) {
-            return rb_funcall(mMarshal, id_load, 1, blob);
-        } else { /* sym_plain and any other symbol */
+        if (force_format == cb_sym_document) {
+            return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
+        } else if (force_format == cb_sym_marshal) {
+            return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
+        } else { /* cb_sym_plain and any other cb_symbol */
             return blob;
         }
     } else {
-        uint32_t flags = ((uint32_t)args[1] & FMT_MASK);
+        uint32_t flags = ((uint32_t)args[1] & CB_FMT_MASK);
 
         switch (flags) {
-            case FMT_DOCUMENT:
-                return rb_funcall(mMultiJson, id_load, 1, blob);
-            case FMT_MARSHAL:
-                return rb_funcall(mMarshal, id_load, 1, blob);
-            case FMT_PLAIN:
+            case CB_FMT_DOCUMENT:
+                return rb_funcall(cb_mMultiJson, cb_id_load, 1, blob);
+            case CB_FMT_MARSHAL:
+                return rb_funcall(cb_mMarshal, cb_id_load, 1, blob);
+            case CB_FMT_PLAIN:
                 /* fall through */
             default:
                 /* all other formats treated as plain */
@@ -379,7 +379,7 @@ coding_failed(VALUE unused, VALUE exc)
 }
 
     VALUE
-encode_value(VALUE val, uint32_t flags)
+cb_encode_value(VALUE val, uint32_t flags)
 {
     VALUE blob, args[2];
 
@@ -390,7 +390,7 @@ encode_value(VALUE val, uint32_t flags)
 }
 
     VALUE
-decode_value(VALUE blob, uint32_t flags, VALUE force_format)
+cb_decode_value(VALUE blob, uint32_t flags, VALUE force_format)
 {
     VALUE val, args[3];
 
@@ -406,7 +406,7 @@ decode_value(VALUE blob, uint32_t flags, VALUE force_format)
 }
 
     void
-strip_key_prefix(struct bucket_st *bucket, VALUE key)
+cb_strip_key_prefix(struct cb_bucket_st *bucket, VALUE key)
 {
     if (bucket->key_prefix) {
         rb_str_update(key, 0, RSTRING_LEN(bucket->key_prefix_val), STR_NEW_CSTR(""));
@@ -414,7 +414,7 @@ strip_key_prefix(struct bucket_st *bucket, VALUE key)
 }
 
     VALUE
-unify_key(struct bucket_st *bucket, VALUE key, int apply_prefix)
+cb_unify_key(struct cb_bucket_st *bucket, VALUE key, int apply_prefix)
 {
     VALUE ret = Qnil, tmp;
 
@@ -434,7 +434,7 @@ unify_key(struct bucket_st *bucket, VALUE key, int apply_prefix)
 }
 
     void
-cb_build_headers(struct context_st *ctx, const char * const *headers)
+cb_build_headers(struct cb_context_st *ctx, const char * const *headers)
 {
     if (!ctx->headers_built) {
         VALUE key = Qnil, val;