libcouchbase 0.2.0 → 0.3.1

data/ext/libcouchbase/src/internal.h

@@ -57,15 +57,12 @@ namespace lcb {
 class Connspec;
 struct Spechost;
 class RetryQueue;
-class Bootstrap;
-namespace clconfig {
-struct Confmon;
-class ConfigInfo;
-}
 }
 extern "C" {
 #endif
 
+struct lcb_string_st;
+
 struct lcb_callback_st {
     lcb_RESPCALLBACK v3callbacks[LCB_CALLBACK__MAX];
     lcb_get_callback get;
@@ -90,31 +87,27 @@ struct lcb_callback_st {
     lcb_pktflushed_callback pktflushed;
 };
 
+struct lcb_confmon_st;
+struct lcb_BOOTSTRAP;
 struct lcb_GUESSVB_st;
 
 #ifdef __cplusplus
 #include <string>
 typedef std::string* lcb_pSCRATCHBUF;
 typedef lcb::RetryQueue lcb_RETRYQ;
-typedef lcb::clconfig::Confmon* lcb_pCONFMON;
-typedef lcb::clconfig::ConfigInfo *lcb_pCONFIGINFO;
-typedef lcb::Bootstrap lcb_BOOTSTRAP;
 #else
 typedef struct lcb_SCRATCHBUF* lcb_pSCRATCHBUF;
 typedef struct lcb_RETRYQ_st lcb_RETRYQ;
-typedef struct lcb_CONFMON_st* lcb_pCONFMON;
-typedef struct lcb_CONFIGINFO_st* lcb_pCONFIGINFO;
-typedef struct lcb_BOOTSTRAP_st lcb_BOOTSTRAP;
 #endif
 
 struct lcb_st {
     mc_CMDQUEUE cmdq; /**< Base command queue object */
     const void *cookie; /**< User defined pointer */
-    lcb_pCONFMON confmon; /**< Cluster config manager */
+    struct lcb_confmon_st *confmon; /**< Cluster config manager */
     hostlist_t mc_nodes; /**< List of current memcached endpoints */
     hostlist_t ht_nodes; /**< List of current management endpoints */
-    lcb_pCONFIGINFO cur_configinfo; /**< Pointer to current config */
-    lcb_BOOTSTRAP *bs_state; /**< Bootstrapping state */
+    struct clconfig_info_st *cur_configinfo; /**< Pointer to current config */
+    struct lcb_BOOTSTRAP *bootstrap; /**< Bootstrapping state */
     struct lcb_callback_st callbacks; /**< Callback table */
     lcb_HISTOGRAM *kv_timings; /**< Histogram object (for timing) */
     lcb_ASPEND pendops; /**< Pending asynchronous requests */
@@ -137,43 +130,9 @@ struct lcb_st {
     lcbio_pTABLE getIOT() { return iotable; }
     inline void add_bs_host(const char *host, int port, unsigned bstype);
     inline void add_bs_host(const lcb::Spechost& host, int defl_http, int defl_cccp);
-    inline lcb_error_t process_dns_srv(lcb::Connspec& spec);
     inline void populate_nodes(const lcb::Connspec&);
-    lcb::Server *get_server(size_t index) const {
-        return static_cast<lcb::Server*>(cmdq.pipelines[index]);
-    }
-    lcb::Server *find_server(const lcb_host_t& host) const;
-    lcb_error_t request_config(const void *cookie, lcb::Server* server);
-
-    /**
-     * @brief Request that the handle update its configuration.
-     *
-     * This function acts as a gateway to the more abstract confmon interface.
-     *
-     * @param instance The instance
-     * @param options A set of options specified as flags, indicating under what
-     * conditions a new configuration should be refetched.
-     *
-     * This should be a combination of one or more @ref lcb::BootstrapOptions
-     *
-     * Note, the definition for this function (and the flags)
-     * are found in bootstrap.cc
-     */
-    inline lcb_error_t bootstrap(unsigned options) {
-        if (!bs_state) {
-            bs_state = new lcb::Bootstrap(this);
-        }
-        return bs_state->bootstrap(options);
-    }
-
-    lcbvb_CONFIG *getConfig() const {
-        return cur_configinfo->vbc;
-    }
-
-    int map_key(const std::string& key) {
-        int srvix, tmpvb;
-        lcbvb_map_key(getConfig(), key.c_str(), key.size(), &tmpvb, &srvix);
-        return srvix;
+    mc_SERVER *get_server(size_t index) const {
+        return static_cast<mc_SERVER*>(cmdq.pipelines[index]);
     }
     #endif
 };
@@ -182,7 +141,7 @@ struct lcb_st {
 #define LCBT_NSERVERS(instance) (instance)->cmdq.npipelines
 #define LCBT_NDATASERVERS(instance) LCBVB_NDATASERVERS(LCBT_VBCONFIG(instance))
 #define LCBT_NREPLICAS(instance) LCBVB_NREPLICAS(LCBT_VBCONFIG(instance))
-#define LCBT_GET_SERVER(instance, ix) (instance)->cmdq.pipelines[ix]
+#define LCBT_GET_SERVER(instance, ix) ((mc_SERVER *)(instance)->cmdq.pipelines[ix])
 #define LCBT_SETTING(instance, name) (instance)->settings->name
 
 void lcb_initialize_packet_handlers(lcb_t instance);
@@ -190,7 +149,8 @@ void lcb_initialize_packet_handlers(lcb_t instance);
 LCB_INTERNAL_API
 void lcb_maybe_breakout(lcb_t instance);
 
-void lcb_update_vbconfig(lcb_t instance, lcb_pCONFIGINFO config);
+struct clconfig_info_st;
+void lcb_update_vbconfig(lcb_t instance, struct clconfig_info_st *config);
 /**
  * Hashtable wrappers
  */
@@ -226,6 +186,20 @@ lcb_error_t lcb_init_providers2(lcb_t obj,
                                const struct lcb_create_st2 *e_options);
 lcb_error_t lcb_reinit3(lcb_t obj, const char *connstr);
 
+
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_host(lcb_t instance, const lcb_host_t *host);
+
+
+LCB_INTERNAL_API
+mc_SERVER *
+lcb_find_server_by_index(lcb_t instance, int ix);
+
+LCB_INTERNAL_API
+lcb_error_t
+lcb_getconfig(lcb_t instance, const void *cookie, mc_SERVER *server);
+
 int
 lcb_should_retry(const lcb_settings *settings, const mc_PACKET *pkt, lcb_error_t err);
 

data/ext/libcouchbase/src/jsparse/parser.cc

@@ -35,30 +35,27 @@ DECLARE_JSONSL_CALLBACK(initial_pop_callback);
 DECLARE_JSONSL_CALLBACK(meta_header_complete_callback);
 DECLARE_JSONSL_CALLBACK(trailer_pop_callback);
 
-using namespace lcb::jsparse;
-
 /* conform to void */
 #define JOBJ_RESPONSE_ROOT (void*)1
 #define JOBJ_ROWSET (void*)2
 
-template <typename T>
-void NORMALIZE_OFFSETS(const char *& buf, T& len) {
-    buf++;
-    len--;
-}
+#define NORMALIZE_OFFSETS(buf, len) buf++; len--;
+
+#define buffer_append lcb_string_append
 
 /**
  * Gets a buffer, given an (absolute) position offset.
  * It will try to get a buffer of size desired. The actual size is
  * returned in 'actual' (and may be less than desired, maybe even 0)
  */
-const char * Parser::get_buffer_region(size_t pos, size_t desired, size_t *actual)
+static const char *
+get_buffer_region(lcbjsp_PARSER *ctx, size_t pos, size_t desired, size_t *actual)
 {
-    const char *ret = current_buf.c_str() + pos - min_pos;
-    const char *end = current_buf.c_str() + current_buf.size();
+    const char *ret = ctx->current_buf.base + pos - ctx->min_pos;
+    const char *end = ctx->current_buf.base + ctx->current_buf.nused;
     *actual = end - ret;
 
-    if (min_pos > pos) {
+    if (ctx->min_pos > pos) {
         /* swallowed */
         *actual = 0;
         return NULL;
@@ -74,46 +71,55 @@ const char * Parser::get_buffer_region(size_t pos, size_t desired, size_t *actua
 /**
  * Consolidate the meta data into a single parsable string..
  */
-void Parser::combine_meta() {
+static void
+combine_meta(lcbjsp_PARSER *ctx)
+{
     const char *meta_trailer;
     size_t ntrailer;
 
-    if (meta_complete) {
+    if (ctx->meta_complete) {
         return;
     }
 
-    assert(header_len <= meta_buf.size());
+    assert(ctx->header_len <= ctx->meta_buf.nused);
 
     /* Adjust the length for the first portion */
-    meta_buf.resize(header_len);
+    ctx->meta_buf.nused = ctx->header_len;
 
     /* Append any trailing data */
-    meta_trailer = get_buffer_region(last_row_endpos, -1, &ntrailer);
-    meta_buf.append(meta_trailer, ntrailer);
-    meta_complete = 1;
+    meta_trailer = get_buffer_region(ctx, ctx->last_row_endpos, -1, &ntrailer);
+
+    buffer_append(&ctx->meta_buf, meta_trailer, ntrailer);
+    ctx->meta_complete = 1;
 }
 
-static Parser * get_ctx(jsonsl_t jsn) {
-    return reinterpret_cast<Parser*>(jsn->data);
+static lcbjsp_PARSER *
+get_ctx(jsonsl_t jsn)
+{
+    return reinterpret_cast<lcbjsp_PARSER*>(jsn->data);
 }
 
 static void
-meta_header_complete_callback(jsonsl_t jsn, jsonsl_action_t,
-    struct jsonsl_state_st *state, const jsonsl_char_t *)
+meta_header_complete_callback(jsonsl_t jsn, jsonsl_action_t action,
+    struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
-    Parser *ctx = get_ctx(jsn);
-    ctx->meta_buf.append(ctx->current_buf.c_str(), state->pos_begin);
+
+    lcbjsp_PARSER *ctx = get_ctx(jsn);
+    buffer_append(&ctx->meta_buf, ctx->current_buf.base, state->pos_begin);
 
     ctx->header_len = state->pos_begin;
     jsn->action_callback_PUSH = NULL;
+
+    (void)action; (void)at;
 }
 
 
 static void
-row_pop_callback(jsonsl_t jsn, jsonsl_action_t,
-    struct jsonsl_state_st *state, const jsonsl_char_t *)
+row_pop_callback(jsonsl_t jsn, jsonsl_action_t action,
+    struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
-    Parser *ctx = get_ctx(jsn);
+    lcbjsp_ROW dt = { LCBJSP_TYPE_ROW };
+    lcbjsp_PARSER *ctx = get_ctx(jsn);
     const char *rowbuf;
     size_t szdummy;
 
@@ -133,59 +139,71 @@ row_pop_callback(jsonsl_t jsn, jsonsl_action_t,
 
             /* While the entire meta is available to us, the _closing_ part
              * of the meta is handled in a different callback. */
-            ctx->meta_buf.append(ctx->current_buf.c_str(), jsn->pos);
+            buffer_append(&ctx->meta_buf, ctx->current_buf.base, jsn->pos);
             ctx->header_len = jsn->pos;
         }
         return;
     }
 
     ctx->rowcount++;
-    if (!ctx->actions) {
+
+    if (!ctx->callback) {
         return;
     }
 
-    rowbuf = ctx->get_buffer_region(state->pos_begin, -1, &szdummy);
-    Row dt = {{0}};
+    rowbuf = get_buffer_region(ctx, state->pos_begin, -1, &szdummy);
+    dt.type = LCBJSP_TYPE_ROW;
     dt.row.iov_base = (void *)rowbuf;
     dt.row.iov_len = jsn->pos - state->pos_begin + 1;
-    ctx->actions->JSPARSE_on_row(dt);
+    ctx->callback(ctx, &dt);
+
+    (void)action; (void)at;
 }
 
 static int
-parse_error_callback(jsonsl_t jsn, jsonsl_error_t,
-    struct jsonsl_state_st *, jsonsl_char_t *)
+parse_error_callback(jsonsl_t jsn, jsonsl_error_t error,
+    struct jsonsl_state_st *state, jsonsl_char_t *at)
 {
-    Parser *ctx = get_ctx(jsn);
+    lcbjsp_PARSER *ctx = get_ctx(jsn);
+    lcbjsp_ROW dt;
+
     ctx->have_error = 1;
 
     /* invoke the callback */
-    if (ctx->actions) {
-        ctx->actions->JSPARSE_on_error(ctx->current_buf);
-        ctx->actions = NULL;
-    }
+    dt.type = LCBJSP_TYPE_ERROR;
+    dt.row.iov_base = ctx->current_buf.base;
+    dt.row.iov_len = ctx->current_buf.nused;
+    ctx->callback(ctx, &dt);
+
+    (void)error; (void)state; (void)at;
+
     return 0;
 }
 
 static void
-trailer_pop_callback(jsonsl_t jsn, jsonsl_action_t,
-    struct jsonsl_state_st *state, const jsonsl_char_t *)
+trailer_pop_callback(jsonsl_t jsn, jsonsl_action_t action,
+    struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
-    Parser *ctx = get_ctx(jsn);
+    lcbjsp_PARSER *ctx = get_ctx(jsn);
+    lcbjsp_ROW dt;
     if (state->data != JOBJ_RESPONSE_ROOT) {
         return;
     }
-    ctx->combine_meta();
-    if (ctx->actions) {
-        ctx->actions->JSPARSE_on_complete(ctx->meta_buf);
-        ctx->actions = NULL;
-    }
+    combine_meta(ctx);
+    dt.row.iov_base = ctx->meta_buf.base;
+    dt.row.iov_len = ctx->meta_buf.nused;
+    dt.type = LCBJSP_TYPE_COMPLETE;
+    ctx->callback(ctx, &dt);
+
+    (void)action; (void)at;
 }
 
 static void
-initial_pop_callback(jsonsl_t jsn, jsonsl_action_t,
-    struct jsonsl_state_st *state, const jsonsl_char_t *)
+initial_pop_callback(jsonsl_t jsn, jsonsl_action_t action,
+    struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
-    Parser *ctx = get_ctx(jsn);
+    lcbjsp_PARSER *ctx = get_ctx(jsn);
+    char *key;
     unsigned long len;
 
     if (ctx->have_error) {
@@ -198,10 +216,14 @@ initial_pop_callback(jsonsl_t jsn, jsonsl_action_t,
         return;
     }
 
-    const char *key = ctx->current_buf.c_str() + state->pos_begin;
+    key = ctx->current_buf.base + state->pos_begin;
     len = jsn->pos - state->pos_begin;
     NORMALIZE_OFFSETS(key, len);
-    ctx->last_hk.assign(key, len);
+
+    lcb_string_clear(&ctx->last_hk);
+    buffer_append(&ctx->last_hk, key, len);
+
+    (void)action; (void)at;
 }
 
 /**
@@ -209,10 +231,10 @@ initial_pop_callback(jsonsl_t jsn, jsonsl_action_t,
  * for the row set.
  */
 static void
-initial_push_callback(jsonsl_t jsn, jsonsl_action_t,
-    struct jsonsl_state_st *state, const jsonsl_char_t *)
+initial_push_callback(jsonsl_t jsn, jsonsl_action_t action,
+    struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
-    Parser *ctx = (Parser*)jsn->data;
+    lcbjsp_PARSER *ctx = (lcbjsp_PARSER*)jsn->data;
     jsonsl_jpr_match_t match = JSONSL_MATCH_UNKNOWN;
 
     if (ctx->have_error) {
@@ -220,10 +242,11 @@ initial_push_callback(jsonsl_t jsn, jsonsl_action_t,
     }
 
     if (JSONSL_STATE_IS_CONTAINER(state)) {
-        jsonsl_jpr_match_state(jsn, state, ctx->last_hk.c_str(), ctx->last_hk.size(),
+        jsonsl_jpr_match_state(jsn, state, ctx->last_hk.base, ctx->last_hk.nused,
             &match);
     }
-    ctx->last_hk.clear();
+
+    lcb_string_clear(&ctx->last_hk);
 
     if (ctx->initialized == 0) {
         if (state->type != JSONSL_T_OBJECT) {
@@ -247,119 +270,149 @@ initial_push_callback(jsonsl_t jsn, jsonsl_action_t,
         jsn->action_callback_PUSH = meta_header_complete_callback;
         state->data = JOBJ_ROWSET;
     }
+
+    (void)action; /* always PUSH */
+    (void)at;
 }
 
-void Parser::feed(const char *data_, size_t ndata)
+static void
+feed_data(lcbjsp_PARSER *ctx, const char *data, size_t ndata)
 {
-    size_t old_len = current_buf.size();
-    current_buf.append(data_, ndata);
-    jsonsl_feed(jsn, current_buf.c_str() + old_len, ndata);
+    size_t old_len = ctx->current_buf.nused;
+
+    buffer_append(&ctx->current_buf, data, ndata);
+    jsonsl_feed(ctx->jsn, ctx->current_buf.base + old_len, ndata);
 
     /* Do we need to cut off some bytes? */
-    if (keep_pos > min_pos) {
-        current_buf.erase(0, keep_pos - min_pos);
+    if (ctx->keep_pos > ctx->min_pos) {
+        size_t lentmp, diff = ctx->keep_pos - ctx->min_pos;
+        const char *buf = get_buffer_region(ctx, ctx->keep_pos, -1, &lentmp);
+        memmove(ctx->current_buf.base, buf, ctx->current_buf.nused - diff);
+        ctx->current_buf.nused -= diff;
     }
 
-    min_pos = keep_pos;
+    ctx->min_pos = ctx->keep_pos;
 }
 
-const char* Parser::jprstr_for_mode(Mode mode) {
-    switch (mode) {
-    case MODE_VIEWS:
-        return "/rows/^";
-    case MODE_N1QL:
-        return "/results/^";
-    case MODE_FTS:
-        return "/hits/^";
-    default:
-        lcb_assert(0 && "Invalid mode passed!");
-        return "/";
-    }
+/* Non-static wrapper */
+void
+lcbjsp_feed(lcbjsp_PARSER *ctx, const char *data, size_t ndata)
+{
+    feed_data(ctx, data, ndata);
 }
 
-Parser::Parser(Mode mode_, Parser::Actions* actions_) :
-    jsn(jsonsl_new(512)),
-    jsn_rdetails(jsonsl_new(32)),
-    jpr(jsonsl_jpr_new(jprstr_for_mode(mode_), NULL)),
-    mode(mode_),
-    have_error(0),
-    initialized(0),
-    meta_complete(0),
-    rowcount(0),
-    min_pos(0),
-    keep_pos(0),
-    header_len(0),
-    last_row_endpos(0),
-    cxx_data(),
-    actions(actions_) {
-
-    jsonsl_jpr_match_state_init(jsn, &jpr, 1);
-    reset();
+lcbjsp_PARSER*
+lcbjsp_create(int mode)
+{
+    lcbjsp_PARSER *ctx;
+    jsonsl_error_t err;
+
+    ctx = reinterpret_cast<lcbjsp_PARSER*>(calloc(1, sizeof(*ctx)));
+    ctx->jsn = jsonsl_new(512);
+    ctx->mode = mode;
+    ctx->cxx_data = new Json::Value();
+
+    if (ctx->mode == LCBJSP_MODE_VIEWS) {
+        ctx->jpr = jsonsl_jpr_new("/rows/^", &err);
+    } else if (ctx->mode == LCBJSP_MODE_N1QL) {
+        ctx->jpr = jsonsl_jpr_new("/results/^", &err);
+    } else {
+        ctx->jpr = jsonsl_jpr_new("/hits/^", &err);
+    }
+    ctx->jsn_rdetails = jsonsl_new(32);
+
+    lcb_string_init(&ctx->meta_buf);
+    lcb_string_init(&ctx->current_buf);
+    lcb_string_init(&ctx->last_hk);
+
+    if (!ctx->jpr) { abort(); }
+    if (!ctx->jsn_rdetails) { abort(); }
+
+    jsonsl_jpr_match_state_init(ctx->jsn, &ctx->jpr, 1);
+    assert(ctx->jsn_rdetails);
+
+    lcbjsp_reset(ctx);
+    assert(ctx->jsn_rdetails);
+    return ctx;
 }
 
-void Parser::get_postmortem(lcb_IOV &out) const {
-    if (meta_complete) {
-        out.iov_base = const_cast<char*>(meta_buf.c_str());
-        out.iov_len = meta_buf.size();
+void
+lcbjsp_get_postmortem(const lcbjsp_PARSER *v, lcb_IOV *out)
+{
+    if (v->meta_complete) {
+        out->iov_base = v->meta_buf.base;
+        out->iov_len = v->meta_buf.nused;
     } else {
-        out.iov_base = const_cast<char*>(current_buf.c_str());
-        out.iov_len = current_buf.size();
+        out->iov_base = v->current_buf.base;
+        out->iov_len = v->current_buf.nused;
     }
 }
 
-void Parser::reset() {
+void
+lcbjsp_reset(lcbjsp_PARSER* ctx)
+{
     /**
      * We create a copy, and set its relevant fields. All other
      * fields are zeroed implicitly. Then we copy the object back.
      */
-    jsonsl_reset(jsn);
-    jsonsl_reset(jsn_rdetails);
-    current_buf.clear();
-    meta_buf.clear();
-    last_hk.clear();
+    jsonsl_reset(ctx->jsn);
+    jsonsl_reset(ctx->jsn_rdetails);
+
+    lcb_string_clear(&ctx->current_buf);
+    lcb_string_clear(&ctx->meta_buf);
+    lcb_string_clear(&ctx->last_hk);
 
     /* Initially all callbacks are enabled so that we can search for the
      * rows array. */
-    jsn->action_callback_POP = initial_pop_callback;
-    jsn->action_callback_PUSH = initial_push_callback;
-    jsn->error_callback = parse_error_callback;
-    jsn->max_callback_level = 4;
-    jsn->data = this;
-    jsonsl_enable_all_callbacks(jsn);
-
-    have_error = 0;
-    initialized = 0;
-    meta_complete = 0;
-    rowcount = 0;
-    min_pos = 0;
-    keep_pos = 0;
-    header_len = 0;
-    last_row_endpos = 0;
-    cxx_data.clear();
+    ctx->jsn->action_callback_POP = initial_pop_callback;
+    ctx->jsn->action_callback_PUSH = initial_push_callback;
+    ctx->jsn->error_callback = parse_error_callback;
+    ctx->jsn->max_callback_level = 4;
+    ctx->jsn->data = ctx;
+    jsonsl_enable_all_callbacks(ctx->jsn);
+
+    ctx->have_error = 0;
+    ctx->initialized = 0;
+    ctx->meta_complete = 0;
+    ctx->rowcount = 0;
+    ctx->min_pos = 0;
+    ctx->keep_pos = 0;
+    ctx->header_len = 0;
+    ctx->last_row_endpos = 0;
+    reinterpret_cast<Json::Value*>(ctx->cxx_data)->clear();
 }
 
-Parser::~Parser() {
-    jsonsl_jpr_match_state_cleanup(jsn);
-    jsonsl_destroy(jsn);
-    jsonsl_destroy(jsn_rdetails);
-    jsonsl_jpr_destroy(jpr);
+void
+lcbjsp_free(lcbjsp_PARSER *ctx)
+{
+    jsonsl_jpr_match_state_cleanup(ctx->jsn);
+    jsonsl_destroy(ctx->jsn);
+    jsonsl_destroy(ctx->jsn_rdetails);
+    jsonsl_jpr_destroy(ctx->jpr);
+
+    lcb_string_release(&ctx->current_buf);
+    lcb_string_release(&ctx->meta_buf);
+    lcb_string_release(&ctx->last_hk);
+    delete reinterpret_cast<Json::Value*>(ctx->cxx_data);
+
+    free(ctx);
 }
 
 typedef struct {
     const char *root;
     lcb_IOV *next_iov;
-    Row *datum;
-    Parser *parent;
+    lcbjsp_ROW *datum;
+    lcbjsp_PARSER *parent;
 } miniparse_ctx;
 
 static void
-parse_json_docid(lcb_IOV* iov, Parser *parent)
+parse_json_docid(lcb_IOV* iov, lcbjsp_PARSER *parent)
 {
     Json::Reader r;
     const char *s = static_cast<char*>(iov->iov_base);
     const char *s_end = s + iov->iov_len;
-    Json::Value& jvp = parent->cxx_data;
-    bool rv = r.parse(s, s_end, jvp);
+    Json::Value *jvp = reinterpret_cast<Json::Value*>(parent->cxx_data);
+    bool rv = r.parse(s, s_end, *jvp);
     if (!rv) {
         // fprintf(stderr, "libcouchbase: Failed to parse document ID as JSON!\n");
         return;
@@ -368,10 +421,10 @@ parse_json_docid(lcb_IOV* iov, Parser *parent)
     s = NULL;
     s_end = NULL;
 
-    assert(jvp.isString());
+    assert(jvp->isString());
 
     // Re-use s and s_end values for the string value itself
-    if (!jvp.getString(&s, &s_end)) {
+    if (!jvp->getString(&s, &s_end)) {
         // fprintf(stderr, "libcouchbase: couldn't get string value!\n");
         iov->iov_base = NULL;
         iov->iov_len = 0;
@@ -381,7 +434,7 @@ parse_json_docid(lcb_IOV* iov, Parser *parent)
 }
 
 static void
-miniparse_callback(jsonsl_t jsn, jsonsl_action_t,
+miniparse_callback(jsonsl_t jsn, jsonsl_action_t action,
     struct jsonsl_state_st *state, const jsonsl_char_t *at)
 {
     miniparse_ctx *ctx = reinterpret_cast<miniparse_ctx*>(jsn->data);
@@ -443,21 +496,24 @@ miniparse_callback(jsonsl_t jsn, jsonsl_action_t,
             iov->iov_len++;
         }
     }
+    (void)at; (void)action;
 }
 
-void Parser::parse_viewrow(Row &vr) {
+void
+lcbjsp_parse_viewrow(lcbjsp_PARSER *vp, lcbjsp_ROW *vr)
+{
     miniparse_ctx ctx = { NULL };
-    ctx.datum = &vr;
-    ctx.root = static_cast<const char*>(vr.row.iov_base);
-    ctx.parent = this;
+    ctx.datum = vr;
+    ctx.root = static_cast<const char*>(vr->row.iov_base);
+    ctx.parent = vp;
 
-    jsonsl_reset(jsn_rdetails);
+    jsonsl_reset(vp->jsn_rdetails);
 
-    jsonsl_enable_all_callbacks(jsn_rdetails);
-    jsn_rdetails->max_callback_level = 3;
-    jsn_rdetails->action_callback_POP = miniparse_callback;
-    jsn_rdetails->data = &ctx;
+    jsonsl_enable_all_callbacks(vp->jsn_rdetails);
+    vp->jsn_rdetails->max_callback_level = 3;
+    vp->jsn_rdetails->action_callback_POP = miniparse_callback;
+    vp->jsn_rdetails->data = &ctx;
 
-    jsonsl_feed(jsn_rdetails,
-        static_cast<const char*>(vr.row.iov_base), vr.row.iov_len);
+    jsonsl_feed(vp->jsn_rdetails,
+        static_cast<const char*>(vr->row.iov_base), vr->row.iov_len);
 }