retrieving.cc

#include <libcouchbase/couchbase.h>
#include <libcouchbase/api3.h>
#include <string>
#include <string.h>
#include <iostream>

struct Result {
    std::string value;
    lcb_error_t status;

    Result() : status(LCB_SUCCESS) {
    }
};

extern "C" {
static void
get_callback(lcb_t, int, const lcb_RESPBASE *rb)
{
    // "cast" to specific callback type
    const lcb_RESPGET *resp = reinterpret_cast<const lcb_RESPGET*>(rb);
    Result *my_result = reinterpret_cast<Result*>(rb->cookie);

    my_result->status = resp->rc;
    my_result->value.clear(); // Remove any prior value
    if (resp->rc == LCB_SUCCESS) {
        my_result->value.assign(
            reinterpret_cast<const char*>(resp->value),
            resp->nvalue);
    }
}
}

int
main(int, char **)
{
    lcb_create_st crst;
    lcb_t instance;
    memset(&crst, 0, sizeof crst);

    crst.version = 3;
    crst.v.v3.connstr = "couchbase://10.0.0.31/default";

    lcb_create(&instance, &crst);
    lcb_connect(instance);
    lcb_wait(instance);

    // Store a key first, so we know it will exist later on. In real production
    // environments, we'd also want to install a callback for storage operations
    // so we know if they succeeded
    lcb_CMDSTORE scmd = { 0 };
    const char *key = "a_key";
    const char *value = "{\"some\":\"json\"}";
    LCB_CMD_SET_KEY(&scmd, key, strlen(key));
    LCB_CMD_SET_VALUE(&scmd, value, strlen(value));
    scmd.operation = LCB_SET; // Upsert

    lcb_sched_enter(instance);
    lcb_store3(instance, NULL, &scmd);
    lcb_sched_leave(instance);
    lcb_wait(instance);

    // Install the callback for GET operations. Note this can be done at any
    // time before the operation is scheduled
    lcb_install_callback3(instance, LCB_CALLBACK_GET, get_callback);

    Result my_result;
    lcb_CMDGET gcmd = { 0 };
    LCB_CMD_SET_KEY(&gcmd, key, strlen(key));
    lcb_sched_enter(instance);
    lcb_get3(instance, &my_result, &gcmd);
    lcb_sched_leave(instance);
    lcb_wait(instance);

    std::cout << "Status for getting " << key << ": ";
    std::cout << lcb_strerror(NULL, my_result.status);
    std::cout << ". Value: " << my_result.value << std::endl;

    // Let's see what happens if we get a key that isn't yet stored:
    key = "non-exist-key";
    LCB_CMD_SET_KEY(&gcmd, key, strlen(key));

    lcb_sched_enter(instance);
    lcb_get3(instance, &my_result, &gcmd);
    lcb_sched_leave(instance);
    lcb_wait(instance);
    std::cout << "Status for getting " << key << ": ";
    std::cout << lcb_strerror(NULL, my_result.status) << std::endl;

    lcb_destroy(instance);
}