couchbase.h

Go to the documentation of this file.

/* -*- Mode: C; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
 *     Copyright 2010-2012 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 LIBCOUCHBASE_COUCHBASE_H
#define LIBCOUCHBASE_COUCHBASE_H 1

#define LCB_CONFIG_MCD_PORT 11210
#define LCB_CONFIG_MCD_SSL_PORT 11207
#define LCB_CONFIG_HTTP_PORT 8091
#define LCB_CONFIG_HTTP_SSL_PORT 18091
#define LCB_CONFIG_MCCOMPAT_PORT 11211

struct lcb_st;
typedef struct lcb_st *lcb_t;
struct lcb_http_request_st;
typedef struct lcb_http_request_st *lcb_http_request_t;

#include <stddef.h>
#include <time.h>
#include <stdarg.h>
#include <stdio.h>
#include <libcouchbase/sysdefs.h>
#include <libcouchbase/assert.h>
#include <libcouchbase/visibility.h>
#include <libcouchbase/error.h>
#include <libcouchbase/iops.h>
#include <libcouchbase/http.h>
#include <libcouchbase/configuration.h>
#include <libcouchbase/_cxxwrap.h>

#ifdef __cplusplus
extern "C"{
#endif

typedef lcb_U8 lcb_datatype_t;
typedef lcb_U32 lcb_USECS;

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** INITIALIZATION                                                           **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef enum {
    LCB_TYPE_BUCKET = 0x00, 
    LCB_TYPE_CLUSTER = 0x01 
} lcb_type_t;

#ifndef __LCB_DOXYGEN__
/* These are definitions for some of the older fields of the `lcb_create_st`
 * structure. They are here for backwards compatibility and should not be
 * used by new code */
typedef enum { LCB_CONFIG_TRANSPORT_LIST_END = 0, LCB_CONFIG_TRANSPORT_HTTP = 1, LCB_CONFIG_TRANSPORT_CCCP, LCB_CONFIG_TRANSPORT_MAX } lcb_config_transport_t;
#define LCB_CREATE_V0_FIELDS const char *host; const char *user; const char *passwd; const char *bucket; struct lcb_io_opt_st *io;
#define LCB_CREATE_V1_FIELDS LCB_CREATE_V0_FIELDS lcb_type_t type;
#define LCB_CREATE_V2_FIELDS LCB_CREATE_V1_FIELDS const char *mchosts; const lcb_config_transport_t* transports;
struct lcb_create_st0 { LCB_CREATE_V0_FIELDS };
struct lcb_create_st1 { LCB_CREATE_V1_FIELDS };
struct lcb_create_st2 { LCB_CREATE_V2_FIELDS };
#endif

struct lcb_create_st3 {
    const char *connstr; 
    const char *username; 
    const char *passwd; 
    void *_pad_bucket; /* Padding. Unused */
    struct lcb_io_opt_st *io; 
    lcb_type_t type;
};

struct lcb_create_st {
    int version;

    union lcb_CRST_u {
        struct lcb_create_st0 v0;
        struct lcb_create_st1 v1;
        struct lcb_create_st2 v2;
        struct lcb_create_st3 v3; 
    } v;

#define LCB_CREATEOPT_INIT(cropt, s, iops) do { \
    memset(cropt, 0, sizeof(*cropt)); \
    (cropt)->version = 3; \
    (cropt)->v.v3.connstr = s; \
    (cropt)->v.v3.iops = iops; \
} while (0);

    LCB_DEPR_CTORS_CRST
};

LIBCOUCHBASE_API
lcb_error_t lcb_create(lcb_t *instance, const struct lcb_create_st *options);

LIBCOUCHBASE_API
lcb_error_t lcb_connect(lcb_t instance);

LIBCOUCHBASE_API
void lcb_set_cookie(lcb_t instance, const void *cookie);

LIBCOUCHBASE_API
const void *lcb_get_cookie(lcb_t instance);

LIBCOUCHBASE_API
lcb_error_t lcb_wait(lcb_t instance);

typedef enum {
    LCB_WAIT_DEFAULT = 0x00,

    LCB_WAIT_NOCHECK = 0x01
} lcb_WAITFLAGS;

LIBCOUCHBASE_API
void lcb_wait3(lcb_t instance, lcb_WAITFLAGS flags);

LIBCOUCHBASE_API
void lcb_breakout(lcb_t instance);


typedef void (*lcb_bootstrap_callback)(lcb_t instance, lcb_error_t err);

LIBCOUCHBASE_API
lcb_bootstrap_callback
lcb_set_bootstrap_callback(lcb_t instance, lcb_bootstrap_callback callback);

LIBCOUCHBASE_API
lcb_error_t
lcb_get_bootstrap_status(lcb_t instance);

LIBCOUCHBASE_API
void
lcb_refresh_config(lcb_t instance);

LIBCOUCHBASE_API
void lcb_destroy(lcb_t instance);

typedef void (*lcb_destroy_callback)(const void *cookie);

LIBCOUCHBASE_API
lcb_destroy_callback
lcb_set_destroy_callback(lcb_t, lcb_destroy_callback);
LIBCOUCHBASE_API
void lcb_destroy_async(lcb_t instance, const void *arg);

/******************************************************************************
 ******************************************************************************
 ** IO CREATION                                                              **
 ******************************************************************************
 ******************************************************************************/

typedef enum {
    LCB_IO_OPS_INVALID = 0x00, 
    LCB_IO_OPS_DEFAULT = 0x01, 
    LCB_IO_OPS_LIBEVENT = 0x02,
    LCB_IO_OPS_WINSOCK = 0x03, 
    LCB_IO_OPS_LIBEV = 0x04,
    LCB_IO_OPS_SELECT = 0x05,
    LCB_IO_OPS_WINIOCP = 0x06,
    LCB_IO_OPS_LIBUV = 0x07
} lcb_io_ops_type_t;

typedef struct {
    lcb_io_ops_type_t type; 
    void *cookie; 
} lcb_IOCREATEOPTS_BUILTIN;

#ifndef __LCB_DOXYGEN__
/* These are mostly internal structures which may be in use by older applications.*/
typedef struct { const char *sofile; const char *symbol; void *cookie; } lcb_IOCREATEOPTS_DSO;
typedef struct { lcb_io_create_fn create; void *cookie; } lcb_IOCREATEOPS_FUNCTIONPOINTER;
#endif

struct lcb_create_io_ops_st {
    int version;
    union {
        lcb_IOCREATEOPTS_BUILTIN v0;
        lcb_IOCREATEOPTS_DSO v1;
        lcb_IOCREATEOPS_FUNCTIONPOINTER v2;
    } v;
};

LIBCOUCHBASE_API
lcb_error_t lcb_create_io_ops(lcb_io_opt_t *op, const struct lcb_create_io_ops_st *options);

LIBCOUCHBASE_API
lcb_error_t lcb_destroy_io_ops(lcb_io_opt_t op);
#define LCB__HKFIELDS \
 \
     const void *hashkey; \
     \
     lcb_SIZE nhashkey; 
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** GET                                                                      **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef struct {
    const void *key; 
    lcb_SIZE nkey; 
    lcb_time_t exptime;

    int lock;
    LCB__HKFIELDS
} lcb_GETCMDv0;

typedef struct lcb_get_cmd_st {
    int version;
    union { lcb_GETCMDv0 v0; } v;
    LCB_DEPR_CTORS_GET
} lcb_get_cmd_t;

#define LCB_DATATYPE_JSON 0x01

typedef enum {
    LCB_VALUE_RAW = 0x00, 
    LCB_VALUE_F_JSON = 0x01, 
    LCB_VALUE_F_SNAPPYCOMP = 0x02 
} lcb_VALUEFLAGS;
typedef struct {
    const void *key;
    lcb_SIZE nkey;
    const void *bytes;
    lcb_SIZE nbytes;
    lcb_U32 flags; 
    lcb_cas_t cas; 
    lcb_U8 datatype; 
} lcb_GETRESPv0;

typedef struct {
    int version;
    union {
        lcb_GETRESPv0 v0;
    } v;
} lcb_get_resp_t;

typedef void (*lcb_get_callback)(lcb_t instance,
                                 const void *cookie,
                                 lcb_error_t error,
                                 const lcb_get_resp_t *resp);

LIBCOUCHBASE_API
lcb_get_callback lcb_set_get_callback(lcb_t, lcb_get_callback callback);

LIBCOUCHBASE_API
lcb_error_t lcb_get(lcb_t instance,
                    const void *command_cookie,
                    lcb_SIZE num,
                    const lcb_get_cmd_t *const *commands);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** GET ITEM FROM REPLICA                                                    **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef struct { const void *key; lcb_SIZE nkey; LCB__HKFIELDS } lcb_GETREPLICACMDv0;

typedef enum {
    LCB_REPLICA_FIRST = 0x00,

    LCB_REPLICA_ALL = 0x01,

    LCB_REPLICA_SELECT = 0x02
} lcb_replica_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    LCB__HKFIELDS
    lcb_replica_t strategy; 
    int index;
} lcb_GETREPLICACMDv1;

typedef struct lcb_get_replica_cmd_st {
    int version;
    union {
        lcb_GETREPLICACMDv0 v0;
        lcb_GETREPLICACMDv1 v1;
    } v;
    LCB_DEPR_CTORS_RGET
} lcb_get_replica_cmd_t;

LIBCOUCHBASE_API
lcb_error_t lcb_get_replica(lcb_t instance,
                            const void *command_cookie,
                            lcb_SIZE num,
                            const lcb_get_replica_cmd_t *const *commands);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** UNLOCK                                                                   **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_cas_t cas; 
    LCB__HKFIELDS
} lcb_UNLOCKCMDv0;

typedef struct lcb_unlock_cmd_st {
    int version;
    union {
        lcb_UNLOCKCMDv0 v0;
    } v;
    LCB_DEPR_CTORS_UNL
} lcb_unlock_cmd_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
} lcb_UNLOCKRESPv0;

typedef struct {
    int version;
    union {
        lcb_UNLOCKRESPv0 v0;
    } v;
} lcb_unlock_resp_t;

typedef void (*lcb_unlock_callback)(lcb_t instance,
                                    const void *cookie,
                                    lcb_error_t error,
                                    const lcb_unlock_resp_t *resp);
LIBCOUCHBASE_API
lcb_unlock_callback lcb_set_unlock_callback(lcb_t, lcb_unlock_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_unlock(lcb_t instance,
                       const void *command_cookie,
                       lcb_SIZE num,
                       const lcb_unlock_cmd_t *const *commands);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** STORE                                                                    **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef enum {
    LCB_ADD = 0x01,
    LCB_REPLACE = 0x02,
    LCB_SET = 0x03,
    LCB_APPEND = 0x04,
    LCB_PREPEND = 0x05
} lcb_storage_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    const void *bytes; 
    lcb_SIZE nbytes; 
    lcb_U32 flags; 
    lcb_cas_t cas;
    lcb_U8 datatype; 
    lcb_time_t exptime;
    lcb_storage_t operation; 
    LCB__HKFIELDS
} lcb_STORECMDv0;

typedef struct lcb_store_cmd_st {
    int version;
    union {
        lcb_STORECMDv0 v0;
    } v;
    LCB_DEPR_CTORS_STORE
} lcb_store_cmd_t;

typedef struct {
    const void *key; 
    lcb_SIZE nkey; 
    lcb_cas_t cas; 
} lcb_STORERESPv0;

typedef struct {
    int version;
    union {
        lcb_STORERESPv0 v0;
    } v;
} lcb_store_resp_t;

typedef void (*lcb_store_callback)(lcb_t instance,
                                   const void *cookie,
                                   lcb_storage_t operation,
                                   lcb_error_t error,
                                   const lcb_store_resp_t *resp);

LIBCOUCHBASE_API
lcb_store_callback lcb_set_store_callback(lcb_t, lcb_store_callback callback);

LIBCOUCHBASE_API
lcb_error_t lcb_store(lcb_t instance,
                      const void *command_cookie,
                      lcb_SIZE num,
                      const lcb_store_cmd_t *const *commands);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** INCR/DECR/ARITHMETIC                                                     **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef struct {
    const void *key;
    lcb_SIZE nkey;

    lcb_time_t exptime;

    int create;

    lcb_S64 delta;

    lcb_U64 initial;
    LCB__HKFIELDS
} lcb_ARITHCMDv0;

typedef struct lcb_arithmetic_cmd_st {
    int version;
    union {  lcb_ARITHCMDv0 v0; } v;

    LCB_DEPR_CTORS_ARITH
} lcb_arithmetic_cmd_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_U64 value; 
    lcb_cas_t cas;
} lcb_ARITHRESPv0;

typedef struct {
    int version;
    union {
        lcb_ARITHRESPv0 v0;
    } v;
} lcb_arithmetic_resp_t;

typedef void (*lcb_arithmetic_callback)(lcb_t instance,
                                        const void *cookie,
                                        lcb_error_t error,
                                        const lcb_arithmetic_resp_t *resp);

LIBCOUCHBASE_API
lcb_arithmetic_callback lcb_set_arithmetic_callback(lcb_t,
                                                    lcb_arithmetic_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_arithmetic(lcb_t instance,
                           const void *command_cookie,
                           lcb_SIZE num,
                           const lcb_arithmetic_cmd_t *const *commands);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** OBSERVE                                                                  **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef enum {
    LCB_OBSERVE_MASTER_ONLY = 0x01
} lcb_observe_options_t;

#define LCB_OBSERVE_FIELDS_COMMON \
    const void *key; \
    lcb_SIZE nkey; \
    LCB__HKFIELDS 
typedef struct {
    LCB_OBSERVE_FIELDS_COMMON
} lcb_OBSERVECMDv0;

typedef struct {
    LCB_OBSERVE_FIELDS_COMMON
    lcb_observe_options_t options;
} lcb_OBSERVECMDv1;

typedef struct lcb_observe_cmd_st {
    int version;
    union {
        lcb_OBSERVECMDv0 v0;
        lcb_OBSERVECMDv1 v1;
    } v;

    LCB_DEPR_CTORS_OBS
} lcb_observe_cmd_t;

typedef enum {
    LCB_OBSERVE_FOUND = 0x00,
    LCB_OBSERVE_PERSISTED = 0x01,
    LCB_OBSERVE_NOT_FOUND = 0x80,
    LCB_OBSERVE_LOGICALLY_DELETED = 0x81,

    LCB_OBSERVE_MAX = 0x82
} lcb_observe_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_cas_t cas; 
    lcb_observe_t status; 
    int from_master; 
    lcb_time_t ttp; 
    lcb_time_t ttr; 
} lcb_OBSERVERESPv0;

typedef struct {
    int version;
    union {
        lcb_OBSERVERESPv0 v0;
    } v;
} lcb_observe_resp_t;

typedef void (*lcb_observe_callback)(lcb_t instance,
                                     const void *cookie,
                                     lcb_error_t error,
                                     const lcb_observe_resp_t *resp);

LIBCOUCHBASE_API
lcb_observe_callback lcb_set_observe_callback(lcb_t, lcb_observe_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_observe(lcb_t instance,
                        const void *command_cookie,
                        lcb_SIZE num,
                        const lcb_observe_cmd_t *const *commands);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** REMOVE/DELETE                                                            **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_cas_t cas;
    LCB__HKFIELDS 
} lcb_REMOVECMDv0;

typedef struct lcb_remove_cmd_st {
    int version;
    union {
        lcb_REMOVECMDv0 v0;
    } v;
    LCB_DEPR_CTORS_RM
} lcb_remove_cmd_t;


typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_cas_t cas;
} lcb_REMOVERESPv0;

typedef struct {
    int version;
    union {
        lcb_REMOVERESPv0 v0;
    } v;
} lcb_remove_resp_t;


typedef void (*lcb_remove_callback)(lcb_t instance,
                                    const void *cookie,
                                    lcb_error_t error,
                                    const lcb_remove_resp_t *resp);

LIBCOUCHBASE_API
lcb_remove_callback lcb_set_remove_callback(lcb_t, lcb_remove_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_remove(lcb_t instance,
                       const void *command_cookie,
                       lcb_SIZE num,
                       const lcb_remove_cmd_t *const *commands);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** TOUCH                                                                    **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef lcb_get_cmd_t lcb_touch_cmd_t;
typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_cas_t cas;
} lcb_TOUCHRESPv0;
typedef struct {
    int version;
    union {
        lcb_TOUCHRESPv0 v0;
    } v;
} lcb_touch_resp_t;

typedef void (*lcb_touch_callback)(lcb_t instance,
                                   const void *cookie,
                                   lcb_error_t error,
                                   const lcb_touch_resp_t *resp);
LIBCOUCHBASE_API
lcb_touch_callback lcb_set_touch_callback(lcb_t, lcb_touch_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_touch(lcb_t instance,
                      const void *cookie,
                      lcb_SIZE num,
                      const lcb_touch_cmd_t *const *commands);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** DURABILITY                                                               **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/

typedef struct {
    const void *key;
    size_t nkey;
    LCB__HKFIELDS 
    lcb_cas_t cas;
} lcb_DURABILITYCMDv0;

typedef struct lcb_durability_cmd_st {
    int version;
    union {
        lcb_DURABILITYCMDv0 v0;
    } v;
} lcb_durability_cmd_t;

typedef struct {
    lcb_U32 timeout;

    lcb_U32 interval;

    lcb_U16 persist_to;

    lcb_U16 replicate_to;

    lcb_U8 check_delete;

    lcb_U8 cap_max;
} lcb_DURABILITYOPTSv0;

typedef struct lcb_durability_opts_st {
    int version;
    union {
        lcb_DURABILITYOPTSv0 v0;
    } v;
} lcb_durability_opts_t;

typedef struct {
    const void *key;
    lcb_SIZE nkey;
    lcb_error_t err;

    lcb_cas_t cas;

    unsigned char persisted_master;

    unsigned char exists_master;

    unsigned char npersisted;

    unsigned char nreplicated;

    unsigned short nresponses;
} lcb_DURABILITYRESPv0;

typedef struct lcb_durability_resp_st {
    int version;
    union {
        lcb_DURABILITYRESPv0 v0;
    } v;
} lcb_durability_resp_t;

LIBCOUCHBASE_API
lcb_error_t lcb_durability_poll(lcb_t instance,
                                const void *cookie,
                                const lcb_durability_opts_t *options,
                                lcb_SIZE ncmds,
                                const lcb_durability_cmd_t *const *cmds);

typedef void (*lcb_durability_callback)(lcb_t instance,
                                        const void *cookie,
                                        lcb_error_t err,
                                        const lcb_durability_resp_t *res);

LIBCOUCHBASE_API
lcb_durability_callback lcb_set_durability_callback(lcb_t,
                                                    lcb_durability_callback);
/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** STATS                                                                    **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef struct {
    const void *name; 
    lcb_SIZE nname; 
} lcb_STATSCMDv0;

typedef struct lcb_server_stats_cmd_st {
    int version;
    union { lcb_STATSCMDv0 v0; } v;
    LCB_DEPR_CTORS_STATS
} lcb_server_stats_cmd_t;

typedef struct {
    const char *server_endpoint; 
    const void *key; 
    lcb_SIZE nkey;
    const void *bytes; 
    lcb_SIZE nbytes;
} lcb_STATSRESPv0;

typedef struct lcb_server_stat_resp_st {
    int version;
    union {
        lcb_STATSRESPv0 v0;
    } v;
} lcb_server_stat_resp_t;

typedef void (*lcb_stat_callback)(lcb_t instance,
                                  const void *cookie,
                                  lcb_error_t error,
                                  const lcb_server_stat_resp_t *resp);
LIBCOUCHBASE_API
lcb_stat_callback lcb_set_stat_callback(lcb_t, lcb_stat_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_server_stats(lcb_t instance,
                             const void *command_cookie,
                             lcb_SIZE num,
                             const lcb_server_stats_cmd_t *const *commands);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** MEMCACHED VERSION (LEGACY)                                               **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef struct lcb_server_version_cmd_st {
    int version;
    union { struct { const void *notused; } v0; } v;
    LCB_DEPR_CTORS_VERSIONS
} lcb_server_version_cmd_t;

typedef struct lcb_server_version_resp_st {
    int version;
    union {
        struct {
            const char *server_endpoint;
            const char *vstring;
            lcb_SIZE nvstring;
        } v0;
    } v;
} lcb_server_version_resp_t;

LIBCOUCHBASE_API
lcb_error_t lcb_server_versions(lcb_t instance,
                                const void *command_cookie,
                                lcb_SIZE num,
                                const lcb_server_version_cmd_t *const *commands);

typedef void (*lcb_version_callback)(lcb_t instance,
                                     const void *cookie,
                                     lcb_error_t error,
                                     const lcb_server_version_resp_t *resp);

LIBCOUCHBASE_API
lcb_version_callback lcb_set_version_callback(lcb_t, lcb_version_callback);


/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** MEMCACHED VERBOSITY                                                      **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef enum {
    LCB_VERBOSITY_DETAIL = 0x00,

    LCB_VERBOSITY_DEBUG = 0x01,

    LCB_VERBOSITY_INFO = 0x02,

    LCB_VERBOSITY_WARNING = 0x03
} lcb_verbosity_level_t;

typedef struct {
    const char *server;
    lcb_verbosity_level_t level;
} lcb_VERBOSITYCMDv0;

typedef struct lcb_verbosity_cmd_st {
    int version;
    union {
        lcb_VERBOSITYCMDv0 v0;
    } v;
    LCB_DEPR_CTORS_VERBOSITY
} lcb_verbosity_cmd_t;

typedef struct lcb_verbosity_resp_st {
    int version;
    union {
        struct {
            const char *server_endpoint;
        } v0;
    } v;
} lcb_verbosity_resp_t;

LIBCOUCHBASE_API
lcb_error_t lcb_set_verbosity(lcb_t instance,
                              const void *command_cookie,
                              lcb_SIZE num,
                              const lcb_verbosity_cmd_t *const *commands);

typedef void (*lcb_verbosity_callback)(lcb_t instance,
                                       const void *cookie,
                                       lcb_error_t error,
                                       const lcb_verbosity_resp_t *resp);

LIBCOUCHBASE_API
lcb_verbosity_callback lcb_set_verbosity_callback(lcb_t,
                                                  lcb_verbosity_callback);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** MEMCACHED FLUSH                                                          **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef struct lcb_flush_cmd_st {
    int version;
    union { struct { int unused; } v0; } v;
    LCB_DEPR_CTORS_FLUSH
} lcb_flush_cmd_t;

typedef struct lcb_flush_resp_st {
    int version;
    union {
        struct {
            const char *server_endpoint;
        } v0;
    } v;
} lcb_flush_resp_t;

LIBCOUCHBASE_API
lcb_error_t lcb_flush(lcb_t instance, const void *cookie,
                      lcb_SIZE num,
                      const lcb_flush_cmd_t *const *commands);

typedef void (*lcb_flush_callback)(lcb_t instance,
                                   const void *cookie,
                                   lcb_error_t error,
                                   const lcb_flush_resp_t *resp);
LIBCOUCHBASE_API
lcb_flush_callback lcb_set_flush_callback(lcb_t, lcb_flush_callback);

/******************************************************************************
 ******************************************************************************
 ******************************************************************************
 ** HTTP                                                                     **
 ******************************************************************************
 ******************************************************************************
 ******************************************************************************/
typedef enum {
    LCB_HTTP_TYPE_VIEW = 0,

    LCB_HTTP_TYPE_MANAGEMENT = 1,

    LCB_HTTP_TYPE_RAW = 2,
    LCB_HTTP_TYPE_MAX = 3
} lcb_http_type_t;

typedef enum {
    LCB_HTTP_METHOD_GET = 0,
    LCB_HTTP_METHOD_POST = 1,
    LCB_HTTP_METHOD_PUT = 2,
    LCB_HTTP_METHOD_DELETE = 3,
    LCB_HTTP_METHOD_MAX = 4
} lcb_http_method_t;

typedef struct {
    const char *path;
    lcb_SIZE npath; 
    const void *body; 
    lcb_SIZE nbody; 
    lcb_http_method_t method;
    int chunked;
    const char *content_type;
} lcb_HTTPCMDv0;

typedef struct {
    const char *path; 
    lcb_SIZE npath;
    const void *body; 
    lcb_SIZE nbody;
    lcb_http_method_t method;
    int chunked;
    const char *content_type;
    const char *host;
    const char *username;
    const char *password;
} lcb_HTTPCMDv1;

typedef struct lcb_http_cmd_st {
    int version;
    union {
        lcb_HTTPCMDv0 v0;
        lcb_HTTPCMDv1 v1;
    } v;
    LCB_DEPR_CTORS_HTTP
} lcb_http_cmd_t;

typedef struct {
    lcb_http_status_t status; 
    const char *path; 
    lcb_SIZE npath;
    const char *const *headers; 
    const void *bytes; 
    lcb_SIZE nbytes;
} lcb_HTTPRESPv0;

typedef struct {
    int version;
    union {
        lcb_HTTPRESPv0 v0;
    } v;
} lcb_http_resp_t;

typedef void (*lcb_http_res_callback)(
        lcb_http_request_t request, lcb_t instance, const void *cookie,
        lcb_error_t error, const lcb_http_resp_t *resp);

typedef lcb_http_res_callback lcb_http_data_callback;
typedef lcb_http_res_callback lcb_http_complete_callback;

LIBCOUCHBASE_API
lcb_http_complete_callback
lcb_set_http_complete_callback(lcb_t, lcb_http_complete_callback);

LIBCOUCHBASE_API
lcb_http_data_callback
lcb_set_http_data_callback(lcb_t, lcb_http_data_callback);

LIBCOUCHBASE_API
lcb_error_t lcb_make_http_request(lcb_t instance,
                                  const void *command_cookie,
                                  lcb_http_type_t type,
                                  const lcb_http_cmd_t *cmd,
                                  lcb_http_request_t *request);

LIBCOUCHBASE_API
void lcb_cancel_http_request(lcb_t instance,
                             lcb_http_request_t request);
typedef enum {
    LCB_NODE_HTCONFIG = 0x01,
    LCB_NODE_DATA = 0x02,
    LCB_NODE_VIEWS = 0x04,
    LCB_NODE_CONNECTED = 0x08,

    LCB_NODE_NEVERNULL = 0x10,

    LCB_NODE_HTCONFIG_CONNECTED = 0x09,

    LCB_NODE_HTCONFIG_ANY = 0x11
} lcb_GETNODETYPE;

#define LCB_GETNODE_UNAVAILABLE "invalid_host:0"

LIBCOUCHBASE_API
const char *
lcb_get_node(lcb_t instance, lcb_GETNODETYPE type, unsigned index);

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_replicas(lcb_t instance);

LIBCOUCHBASE_API
lcb_S32 lcb_get_num_nodes(lcb_t instance);


LIBCOUCHBASE_API
const char *const *lcb_get_server_list(lcb_t instance);

LIBCOUCHBASE_API
int lcb_is_waiting(lcb_t instance);


LIBCOUCHBASE_API
lcb_error_t lcb_cntl(lcb_t instance, int mode, int cmd, void *arg);

LIBCOUCHBASE_API
lcb_error_t
lcb_cntl_string(lcb_t instance, const char *key, const char *value);

LIBCOUCHBASE_API
lcb_error_t lcb_cntl_setu32(lcb_t instance, int cmd, lcb_U32 arg);

LIBCOUCHBASE_API
lcb_U32 lcb_cntl_getu32(lcb_t instance, int cmd);

LIBCOUCHBASE_API
int
lcb_cntl_exists(int ctl); /* settings */ /* lcbt_info */

enum lcb_timeunit_t {
    LCB_TIMEUNIT_NSEC = 0, 
    LCB_TIMEUNIT_USEC = 1, 
    LCB_TIMEUNIT_MSEC = 2, 
    LCB_TIMEUNIT_SEC = 3 
};
typedef enum lcb_timeunit_t lcb_timeunit_t;

LIBCOUCHBASE_API
lcb_error_t lcb_enable_timings(lcb_t instance);


LIBCOUCHBASE_API
lcb_error_t lcb_disable_timings(lcb_t instance);

typedef void (*lcb_timings_callback)(lcb_t instance,
                                     const void *cookie,
                                     lcb_timeunit_t timeunit,
                                     lcb_U32 min,
                                     lcb_U32 max,
                                     lcb_U32 total,
                                     lcb_U32 maxtotal);

LIBCOUCHBASE_API
lcb_error_t lcb_get_timings(lcb_t instance,
                            const void *cookie,
                            lcb_timings_callback callback);
#if !defined(LCB_VERSION_STRING) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION_STRING "unknown"
#endif

#if !defined(LCB_VERSION) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION 0x000000
#endif

#if !defined(LCB_VERSION_CHANGESET) || defined(__LCB_DOXYGEN__)

#define LCB_VERSION_CHANGESET "0xdeadbeef"
#endif

LIBCOUCHBASE_API
const char *lcb_get_version(lcb_U32 *version);

#define LCB_SUPPORTS_SSL 1

#define LCB_SUPPORTS_SNAPPY 2

LIBCOUCHBASE_API
int
lcb_supports_feature(int n);

LIBCOUCHBASE_API
lcb_error_t lcb_errmap_default(lcb_t instance, lcb_U16 code);

typedef lcb_error_t (*lcb_errmap_callback)(lcb_t instance, lcb_U16 bincode);

LIBCOUCHBASE_API
lcb_errmap_callback lcb_set_errmap_callback(lcb_t, lcb_errmap_callback);

LIBCOUCHBASE_API
void *lcb_mem_alloc(lcb_SIZE size);

LIBCOUCHBASE_API
void lcb_mem_free(void *ptr);

LCB_INTERNAL_API
void lcb_run_loop(lcb_t instance);

LCB_INTERNAL_API
void lcb_stop_loop(lcb_t instance);

typedef enum {
    LCB_DUMP_VBCONFIG =  0x01,
    LCB_DUMP_PKTINFO = 0x02,
    LCB_DUMP_BUFINFO = 0x04,
    LCB_DUMP_ALL = 0xff
} lcb_DUMPFLAGS;

LIBCOUCHBASE_API
void
lcb_dump(lcb_t instance, FILE *fp, lcb_U32 flags);

/* Post-include some other headers */
#ifdef __cplusplus
}
#endif /* __cplusplus */

#include <libcouchbase/cntl.h>
#include <libcouchbase/deprecated.h>
#endif /* LIBCOUCHBASE_COUCHBASE_H */