api-legacy.h

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

#ifdef __cplusplus
extern "C" {
#endif

#ifndef LIBCOUCHBASE_COUCHBASE_H
#error "include <libcouchbase/couchbase.h> first!"
#endif


#define LCB__HKFIELDS \
 \
     const void *hashkey; \
     \
     lcb_SIZE nhashkey; 
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;

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);

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

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);

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);
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; 
    const lcb_MUTATION_TOKEN *mutation_token;
} 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);


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;
    const lcb_MUTATION_TOKEN *mutation_token;
} 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);

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 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);

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;
    const lcb_MUTATION_TOKEN *mutation_token;
} 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);

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);

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

typedef struct lcb_durability_cmd_st {
    int version;
    union {
        lcb_DURABILITYCMDv0 v0;
    } v;
} lcb_durability_cmd_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);

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);

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);

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);
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);

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);

#ifdef __cplusplus
}
#endif
#endif