api3.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2014 Couchbase, Inc.
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */

#ifndef LCB_API3_H
#define LCB_API3_H
#include <libcouchbase/kvbuf.h>

#ifdef __cplusplus
extern "C" {
#endif

#define LCB_CMD_BASE \
 \
    lcb_U32 cmdflags; \
    \
 \
    lcb_U32 exptime; \
    \
 \
    lcb_U64 cas; \
    \
 \
    lcb_KEYBUF key; \
    \
 \
    lcb_KEYBUF _hashkey

typedef struct lcb_CMDBASE {
    LCB_CMD_BASE;
} lcb_CMDBASE;

#define LCB_CMD_SET_KEY(cmd, keybuf, keylen) \
        LCB_KREQ_SIMPLE(&(cmd)->key, keybuf, keylen)

#define LCB_RESP_BASE \
    void *cookie;  \
    const void *key;  \
    lcb_SIZE nkey;  \
    lcb_cas_t cas;  \
    lcb_error_t rc;  \
    lcb_U16 version;  \
    lcb_U16 rflags; 
typedef struct {
    LCB_RESP_BASE
} lcb_RESPBASE;

#define LCB_RESP_SERVER_FIELDS \
 \
    const char *server;

typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
} lcb_RESPSERVERBASE;

typedef enum {
    LCB_RESP_F_FINAL = 0x01,

    LCB_RESP_F_CLIENTGEN = 0x02,

    LCB_RESP_F_NMVGEN = 0x04
} lcb_RESPFLAGS;

typedef enum {
    LCB_CALLBACK_DEFAULT = 0, 
    LCB_CALLBACK_GET, 
    LCB_CALLBACK_STORE, 
    LCB_CALLBACK_COUNTER, 
    LCB_CALLBACK_TOUCH, 
    LCB_CALLBACK_REMOVE, 
    LCB_CALLBACK_UNLOCK, 
    LCB_CALLBACK_STATS, 
    LCB_CALLBACK_VERSIONS, 
    LCB_CALLBACK_VERBOSITY, 
    LCB_CALLBACK_FLUSH, 
    LCB_CALLBACK_OBSERVE, 
    LCB_CALLBACK_GETREPLICA, 
    LCB_CALLBACK_ENDURE, 
    LCB_CALLBACK_HTTP, 
    LCB_CALLBACK__MAX /* Number of callbacks */
} lcb_CALLBACKTYPE;

typedef void (*lcb_RESPCALLBACK)
        (lcb_t instance, int cbtype, const lcb_RESPBASE* resp);

LIBCOUCHBASE_API
lcb_RESPCALLBACK
lcb_install_callback3(lcb_t instance, int cbtype, lcb_RESPCALLBACK cb);

LIBCOUCHBASE_API
lcb_RESPCALLBACK
lcb_get_callback3(lcb_t instance, int cbtype);

LIBCOUCHBASE_API
void lcb_sched_enter(lcb_t instance);

LIBCOUCHBASE_API
void lcb_sched_leave(lcb_t instance);


LIBCOUCHBASE_API
void lcb_sched_fail(lcb_t instance);

LIBCOUCHBASE_API
void lcb_sched_flush(lcb_t instance);

typedef struct {
    LCB_CMD_BASE;
    int lock;
} lcb_CMDGET;

typedef struct {
    LCB_RESP_BASE
    const void *value; 
    lcb_SIZE nvalue; 
    void* bufh;
    lcb_datatype_t datatype;
    lcb_U32 itmflags; 
} lcb_RESPGET;

LIBCOUCHBASE_API
lcb_error_t
lcb_get3(lcb_t instance, const void *cookie, const lcb_CMDGET *cmd);

typedef lcb_CMDBASE lcb_CMDUNLOCK;

typedef lcb_RESPBASE lcb_RESPUNLOCK;

LIBCOUCHBASE_API
lcb_error_t
lcb_unlock3(lcb_t instance, const void *cookie, const lcb_CMDUNLOCK *cmd);
typedef struct {
    LCB_CMD_BASE;
    lcb_int64_t delta;
    lcb_U64 initial;
    int create;
} lcb_CMDCOUNTER;

typedef struct {
    LCB_RESP_BASE
    lcb_U64 value;
} lcb_RESPCOUNTER;

LIBCOUCHBASE_API
lcb_error_t
lcb_counter3(lcb_t instance, const void *cookie, const lcb_CMDCOUNTER *cmd);
typedef struct {
    LCB_CMD_BASE;
    lcb_replica_t strategy; 
    int index;
} lcb_CMDGETREPLICA;

LIBCOUCHBASE_API
lcb_error_t
lcb_rget3(lcb_t instance, const void *cookie, const lcb_CMDGETREPLICA *cmd);
typedef struct {
    LCB_CMD_BASE;

    lcb_VALBUF value;
    lcb_U32 flags;
    lcb_datatype_t datatype;
    lcb_storage_t operation;
} lcb_CMDSTORE;

typedef struct {
    LCB_RESP_BASE
    lcb_storage_t op;
} lcb_RESPSTORE;

#define LCB_CMD_SET_VALUE(scmd, valbuf, vallen) do { \
    (scmd)->value.vtype = LCB_KV_COPY; \
    (scmd)->value.u_buf.contig.bytes = valbuf; \
    (scmd)->value.u_buf.contig.nbytes = vallen; \
} while (0);

LIBCOUCHBASE_API
lcb_error_t
lcb_store3(lcb_t instance, const void *cookie, const lcb_CMDSTORE *cmd);
typedef lcb_CMDBASE lcb_CMDREMOVE;

typedef lcb_RESPBASE lcb_RESPREMOVE;

LIBCOUCHBASE_API
lcb_error_t
lcb_remove3(lcb_t instance, const void *cookie, const lcb_CMDREMOVE * cmd);
typedef lcb_CMDBASE lcb_CMDTOUCH;

typedef lcb_RESPBASE lcb_RESPTOUCH;

LIBCOUCHBASE_API
lcb_error_t
lcb_touch3(lcb_t instance, const void *cookie, const lcb_CMDTOUCH *cmd);
typedef lcb_CMDBASE lcb_CMDSTATS;

#define LCB_CMDSTATS_F_KV (1 << 16)

typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
    const char *value; 
    lcb_SIZE nvalue; 
} lcb_RESPSTATS;


LIBCOUCHBASE_API
lcb_error_t
lcb_stats3(lcb_t instance, const void *cookie, const lcb_CMDSTATS * cmd);
typedef struct lcb_MULTICMD_CTX_st {
    lcb_error_t (*addcmd)(struct lcb_MULTICMD_CTX_st *ctx, const lcb_CMDBASE *cmd);

    lcb_error_t (*done)(struct lcb_MULTICMD_CTX_st *ctx, const void *cookie);

    void (*fail)(struct lcb_MULTICMD_CTX_st *ctx);
} lcb_MULTICMD_CTX;

#define LCB_CMDOBSERVE_F_MASTER_ONLY 1<<16

typedef lcb_CMDBASE lcb_CMDOBSERVE;

typedef struct {
    LCB_RESP_BASE
    lcb_U8 status; 
    lcb_U8 ismaster; 
    lcb_U32 ttp; 
    lcb_U32 ttr; 
} lcb_RESPOBSERVE;

LIBCOUCHBASE_API
lcb_MULTICMD_CTX *
lcb_observe3_ctxnew(lcb_t instance);
typedef lcb_CMDBASE lcb_CMDENDURE;

typedef struct {
    LCB_RESP_BASE
    lcb_U16 nresponses; 
    lcb_U8 exists_master; 
    lcb_U8 persisted_master; 
    lcb_U8 npersisted; 
    lcb_U8 nreplicated; 
} lcb_RESPENDURE;

LIBCOUCHBASE_API
lcb_MULTICMD_CTX *
lcb_endure3_ctxnew(lcb_t instance,
    const lcb_durability_opts_t *options, lcb_error_t *err);
typedef struct {
    LCB_RESP_BASE
    LCB_RESP_SERVER_FIELDS
    const char *mcversion; 
    lcb_SIZE nversion; 
} lcb_RESPMCVERSION;

LIBCOUCHBASE_API
lcb_error_t
lcb_server_versions3(lcb_t instance, const void *cookie, const lcb_CMDBASE * cmd);
typedef struct {
    /* unused */
    LCB_CMD_BASE;
    const char *server;
    lcb_verbosity_level_t level;
} lcb_CMDVERBOSITY;
typedef lcb_RESPSERVERBASE lcb_RESPVERBOSITY;
LIBCOUCHBASE_API
lcb_error_t
lcb_server_verbosity3(lcb_t instance, const void *cookie, const lcb_CMDVERBOSITY *cmd);
typedef lcb_CMDBASE lcb_CMDFLUSH;
typedef lcb_RESPSERVERBASE lcb_RESPFLUSH;
LIBCOUCHBASE_API
lcb_error_t
lcb_flush3(lcb_t instance, const void *cookie, const lcb_CMDFLUSH *cmd);
#define LCB_CMDHTTP_F_STREAM 1<<16

typedef struct {
    LCB_CMD_BASE;
    lcb_http_type_t type;
    lcb_http_method_t method; 
    const char *body;

    lcb_SIZE nbody;

    lcb_http_request_t *reqhandle;

    const char *content_type;

    const char *username;

    const char *password;

    const char *host;
} lcb_CMDHTTP;

typedef struct {
    LCB_RESP_BASE
    short htstatus; 
    const char * const * headers;
    const void *body;
    lcb_SIZE nbody;
    lcb_http_request_t _htreq; /* Private */
} lcb_RESPHTTP;

LIBCOUCHBASE_API
lcb_error_t
lcb_http3(lcb_t instance, const void *cookie, const lcb_CMDHTTP *cmd);
#ifdef __cplusplus
}
#endif

#endif /* LCB_API3_H */