todo.txt

mongoc_client_encryption_datakey_opts_set_keyaltnames
mongoc_client_encryption_datakey_opts_set_keymaterial
#define MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_RANDOM "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
#define MONGOC_AEAD_AES_256_CBC_HMAC_SHA_512_DETERMINISTIC "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic"
#define MONGOC_ENCRYPT_ALGORITHM_INDEXED "Indexed"
#define MONGOC_ENCRYPT_ALGORITHM_UNINDEXED "Unindexed"
#define MONGOC_ENCRYPT_ALGORITHM_RANGE "Range"
#define MONGOC_ENCRYPT_QUERY_TYPE_EQUALITY "equality"
#define MONGOC_ENCRYPT_QUERY_TYPE_RANGE "range"
mongoc_delete_flags_t
mongoc_client_session_with_transaction_cb_t
mongoc_client_set_sockettimeouts
mongoc_stream_uncork(stream)
mongoc_stream_cork(stream)
bson_copy_to_excluding (const bson_t *src,
                        bson_t *dst,
                        const char *first_exclude,
                        ...);
bson_copy_to_excluding_noinit_va(src, dst, first_exclude, args);

bson_vsnprintf(str, size, format, ap);
bson_strdupv_printf(format, args);

mongoc_bulkwrite_t *
client_bulkwrite_new(self)
    mongoc_client_t *self;
    CODE:
        RETVAL = mongoc_client_bulkwrite_new(self);
    OUTPUT:
        RETVAL

void
bulkwrite_set_session(self, session)
    mongoc_bulkwrite_t* self;
    mongoc_client_session_t* session;
    CODE:
        mongoc_bulkwrite_set_session(self, session);

void
bulkwrite_destroy(self)
    mongoc_bulkwrite_t* self;
    CODE:
        mongoc_bulkwrite_destroy(self);

bool
bulkwrite_append_deletemany(self, ns, filter, opts, error)
    mongoc_bulkwrite_t *self;
    const char *ns;
    const bson_t *filter;
    const mongoc_bulkwrite_deletemanyopts_t *opts;
    bson_error_t *error;
    CODE:
        if (!self || !ns || !filter || !opts) {
            if (error) {
                bson_set_error(error, MONGOC_ERROR_CLIENT, 0, "Invalid arguments provided.");
            }
            RETVAL = false;
        } else {
            RETVAL = mongoc_bulkwrite_append_deletemany(self, ns, filter, opts, error);
        }
    OUTPUT:
        RETVAL
    
mongoc_bulkwrite_insertoneopts_t*
bulkwrite_insertoneopts_new()
    CODE:
        // Create a new bulk write insert one options object
        RETVAL = mongoc_bulkwrite_insertoneopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_insertoneopts_destroy(self)
    mongoc_bulkwrite_insertoneopts_t* self;
    CODE:
        // Destroy the bulk write insert one options object
        mongoc_bulkwrite_insertoneopts_destroy(self);

bool
bulkwrite_append_insertone(self, ns, document, opts, error)
    mongoc_bulkwrite_t* self;
    const char* ns;
    const bson_t* document;
    const mongoc_bulkwrite_insertoneopts_t* opts;
    bson_error_t* error;
    CODE:
        if (!self || !ns || !document || !opts) {
            if (error) {
                bson_set_error(error, MONGOC_ERROR_CLIENT, 0, "Invalid arguments provided.");
            }
            RETVAL = false;
        } else {
            // Append an insert one operation to the bulk write object
            RETVAL = mongoc_bulkwrite_append_insertone(self, ns, document, opts, error);
        }
    OUTPUT:
        RETVAL

mongoc_bulkwrite_updateoneopts_t*
bulkwrite_updateoneopts_new()
    CODE:
        // Create a new bulk write update one options object
        RETVAL = mongoc_bulkwrite_updateoneopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_updateoneopts_set_arrayfilters(self, arrayfilters)
    mongoc_bulkwrite_updateoneopts_t* self;
    const bson_t* arrayfilters;
    CODE:
        // Set the array filters for the bulk write update one options
        mongoc_bulkwrite_updateoneopts_set_arrayfilters(self, arrayfilters);

void
bulkwrite_updateoneopts_set_collation(self, collation)
    mongoc_bulkwrite_updateoneopts_t* self;
    const bson_t* collation;
    CODE:
        // Set the collation for the bulk write update one options
        mongoc_bulkwrite_updateoneopts_set_collation(self, collation);

void
mongoc_bulkwrite_updateoneopts_set_hint(self, hint)
    mongoc_bulkwrite_updateoneopts_t* self;
    const bson_value_t* hint;
    CODE:
        // Set the hint for the bulk write update one options
        mongoc_bulkwrite_updateoneopts_set_hint(self, hint);

void
bulkwrite_updateoneopts_set_upsert(self, upsert)
    mongoc_bulkwrite_updateoneopts_t* self;
    bool upsert;
    CODE:
        // Set the upsert flag for the bulk write update one options
        mongoc_bulkwrite_updateoneopts_set_upsert(self, upsert);

void
bulkwrite_updateoneopts_destroy(self)
    mongoc_bulkwrite_updateoneopts_t* self;
    CODE:
        // Destroy the bulk write update one options object
        mongoc_bulkwrite_updateoneopts_destroy(self);

bool
bulkwrite_append_updateone(self, ns, filter, update, opts, error)
    mongoc_bulkwrite_t* self;
    const char* ns;
    const bson_t* filter;
    const bson_t* update;
    const mongoc_bulkwrite_updateoneopts_t* opts;
    bson_error_t* error;
    CODE:
        if (!self || !ns || !filter || !update || !opts) {
            if (error) {
                bson_set_error(error, MONGOC_ERROR_CLIENT, 0, "Invalid arguments provided.");
            }
            RETVAL = false;
        } else {
            RETVAL = mongoc_bulkwrite_append_updateone(self, ns, filter, update, opts, error);
        }

mongoc_bulkwrite_updatemanyopts_t*
bulkwrite_updatemanyopts_new()
    CODE:
        RETVAL = mongoc_bulkwrite_updatemanyopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_updatemanyopts_set_arrayfilters(self, arrayfilters)
    mongoc_bulkwrite_updatemanyopts_t* self;
    const bson_t* arrayfilters;
    CODE:
        // Set the array filters for the bulk write update many options
        mongoc_bulkwrite_updatemanyopts_set_arrayfilters(self, arrayfilters);

void
bulkwrite_updatemanyopts_set_collation(self, collation)
    mongoc_bulkwrite_updatemanyopts_t* self;
    const bson_t* collation;
    CODE:
        // Set the collation for the bulk write update many options
        mongoc_bulkwrite_updatemanyopts_set_collation(self, collation);

void
bulkwrite_updatemanyopts_set_hint(self, hint)
    mongoc_bulkwrite_updatemanyopts_t* self;
    const bson_value_t* hint;
    CODE:
        // Set the hint for the bulk write update many options
        mongoc_bulkwrite_updatemanyopts_set_hint(self, hint);

void
bulkwrite_updatemanyopts_set_upsert (self, upsert)
    mongoc_bulkwrite_updatemanyopts_t* self;
    bool upsert;
    CODE:
        mongoc_bulkwrite_updatemanyopts_set_upsert(self, upsert);

void
bulkwrite_updatemanyopts_destroy(self)
    mongoc_bulkwrite_updatemanyopts_t* self;
    CODE:
        mongoc_bulkwrite_updatemanyopts_destroy(self);

bool
bulkwrite_append_updatemany(self, ns, filter, update, opts, error)
    mongoc_bulkwrite_t* self;
    const char* ns;
    const bson_t* filter;
    const bson_t* update;
    const mongoc_bulkwrite_updatemanyopts_t* opts;
    bson_error_t* error;
    CODE:
        if (!self || !ns || !filter || !update || !opts) {
            if (error) {
                bson_set_error(error ,MONGOC_ERROR_CLIENT,0, "Invalid arguments provided.");
            }
            RETVAL = false;
        } else {
            RETVAL = mongoc_bulkwrite_append_updatemany(self, ns, filter, update, opts, error);
        }
    OUTPUT:
        RETVAL

mongoc_bulkwrite_replaceoneopts_t*
bulkwrite_replaceoneopts_new()
    CODE:
        RETVAL = mongoc_bulkwrite_replaceoneopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_replaceoneopts_set_collation(self, collation)
    mongoc_bulkwrite_replaceoneopts_t* self;
    const bson_t* collation;
    CODE:
        mongoc_bulkwrite_replaceoneopts_set_collation(self, collation);

void
bulkwrite_replaceoneopts_set_hint(self, hint)
    mongoc_bulkwrite_replaceoneopts_t* self;
    const bson_value_t* hint;
    CODE:
        mongoc_bulkwrite_replaceoneopts_set_hint(self, hint);

void
bulkwrite_replaceoneopts_set_upsert(self, upsert)
    mongoc_bulkwrite_replaceoneopts_t *self;
    bool upsert;
    CODE:
        mongoc_bulkwrite_replaceoneopts_set_upsert(self, upsert);

void
bulkwrite_replaceoneopts_destroy(self)
    mongoc_bulkwrite_replaceoneopts_t* self;
    CODE:
        mongoc_bulkwrite_replaceoneopts_destroy(self);

bool
bulkwrite_append_replaceone(self, ns, filter, replacement, opts, error)
    mongoc_bulkwrite_t* self;
    const char *ns;
    const bson_t *filter;
    const bson_t *replacement;
    const mongoc_bulkwrite_replaceoneopts_t *opts;
    bson_error_t *error;
    CODE:
        if (!self || !ns || !filter || !replacement || !opts) {
            if (error) {
                bson_set_error(error, MONGOC_ERROR_CLIENT, 0, "Invalid arguments provided.");
            }
            RETVAL = false;
        } else {
            RETVAL = mongoc_bulkwrite_append_replaceone(self, ns, filter, replacement, opts, error);
        }
    OUTPUT:
        RETVAL

mongoc_bulkwrite_deleteoneopts_t*
bulkwrite_deleteoneopts_new()
    CODE:
        RETVAL = mongoc_bulkwrite_deleteoneopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_deleteoneopts_destroy(self)
    mongoc_bulkwrite_deleteoneopts_t* self;
    CODE:
        mongoc_bulkwrite_deleteoneopts_destroy(self);

void
bulkwrite_deleteoneopts_set_collation(self, collation)
    mongoc_bulkwrite_deleteoneopts_t* self;
    const bson_t* collation;
    CODE:
        mongoc_bulkwrite_deleteoneopts_set_collation(self, collation);

void
bulkwrite_deleteoneopts_set_hint(self, hint)
    mongoc_bulkwrite_deleteoneopts_t *self;
    const bson_value_t* hint;
    CODE:
        mongoc_bulkwrite_deleteoneopts_set_hint(self, hint);

bool
bulkwrite_append_deleteone(self, ns, filter, opts, error)
    mongoc_bulkwrite_t *self;
    const char* ns;
    const bson_t* filter;
    const mongoc_bulkwrite_deleteoneopts_t *opts;
    bson_error_t *error;
    CODE:
        if (!self || !ns || !filter || !opts) {
            if (error) {
                bson_set_error(error, MONGOC_ERROR_CLIENT, 0, "Invalid arguments provided.");
                RETVAL = false;
            }
        } else {
            RETVAL = mongoc_bulkwrite_append_deleteone(self, ns, filter, opts, error);
        }
    OUTPUT:
        RETVAL

mongoc_bulkwrite_deletemanyopts_t*
bulkwrite_deletemanyopts_new()
    CODE:
        RETVAL = mongoc_bulkwrite_deletemanyopts_new();
    OUTPUT:
        RETVAL

void
bulkwrite_deletemanyopts_destroy (self)
    mongoc_bulkwrite_deletemanyopts_t* self;
    CODE:
        mongoc_bulkwrite_deletemanyopts_destroy(self);

void
bulkwrite_deletemanyopts_set_collation(self, collation)
    mongoc_bulkwrite_deletemanyopts_t* self;
    const bson_t *collation;
    CODE:
        mongoc_bulkwrite_deletemanyopts_set_collation(self, collation);

void
bulkwrite_deletemanyopts_set_hint(self, hint)
    mongoc_bulkwrite_deletemanyopts_t* self;
    const bson_value_t* hint;
    CODE:
        mongoc_bulkwrite_deletemanyopts_set_hint(self, hint);

mongoc_bulkwrite_insertoneopts_t* T_PTROBJ
mongoc_bulkwrite_t* T_PTROBJ
const mongoc_bulkwrite_insertoneopts_t* T_PTROBJ
const mongoc_bulkwrite_updatemanyopts_t* T_PTROBJ
mongoc_bulkwrite_replaceoneopts_t* T_PTROBJ
const mongoc_bulkwrite_replaceoneopts_t * T_PTROBJ
mongoc_bulkwrite_deleteoneopts_t* T_PTROBJ
const mongoc_bulkwrite_deleteoneopts_t* T_PTROBJ
mongoc_bulkwrite_deletemanyopts_t* T_PTROBJ
const mongoc_bulkwrite_deletemanyopts_t* T_PTROBJ
mongoc_bulkwrite_updateoneopts_t* T_PTROBJ
const mongoc_bulkwrite_updateoneopts_t* T_PTROBJ
mongoc_bulkwrite_updatemanyopts_t* T_PTROBJ
mongoc_bulkwritereturn_t T_PTROBJ
const mongoc_bulkwriteopts_t* T_PTROBJ
mongoc_bulkwriteresult_t* T_PTROBJ
mongoc_bulkwriteexception_t* T_PTROBJ
mongoc_bulkwriteopts_t* T_PTROBJ
const mongoc_bulkwriteresult_t* T_PTROBJ
const mongoc_bulkwriteexception_t * T_PTROBJ

void
bulkwriteresult_destroy(self)
    mongoc_bulkwriteresult_t* self;
    CODE:
        mongoc_bulkwriteresult_destroy(self);

void
bulkwriteexception_destroy(self)
    mongoc_bulkwriteexception_t* self;
    CODE:
        mongoc_bulkwriteexception_destroy(self);

mongoc_bulkwriteopts_t*
bulkwriteopts_new()
    CODE:
        RETVAL = mongoc_bulkwriteopts_new();
    OUTPUT:
        RETVAL

void
bulkwriteopts_set_ordered(self, ordered)
    mongoc_bulkwriteopts_t *self;
    bool ordered;
    CODE:
        mongoc_bulkwriteopts_set_ordered(self, ordered);

void
bulkwriteopts_set_bypassdocumentvalidation(self, bypassdocumentvalidation)
    mongoc_bulkwriteopts_t *self;
    bool bypassdocumentvalidation;
    CODE:
        mongoc_bulkwriteopts_set_bypassdocumentvalidation(self, bypassdocumentvalidation);

void
bulkwriteopts_set_let(self, let)
    mongoc_bulkwriteopts_t* self;
    const bson_t* let;
    CODE:
        mongoc_bulkwriteopts_set_let(self, let);

void
bulkwriteopts_set_writeconcern(self, writeconcern)
    mongoc_bulkwriteopts_t* self;
    const mongoc_write_concern_t *writeconcern;
    CODE:
        mongoc_bulkwriteopts_set_writeconcern(self, writeconcern);

void
bulkwriteopts_set_comment(self, comment)
    mongoc_bulkwriteopts_t *self;
    const bson_value_t *comment;
    CODE:
        mongoc_bulkwriteopts_set_comment(self, comment);

void
bulkwriteopts_set_verboseresults(self, verboseresults)
    mongoc_bulkwriteopts_t *self;
    bool verboseresults;
    CODE:
        mongoc_bulkwriteopts_set_verboseresults(self, verboseresults);

void
bulkwriteopts_set_extra(self, extra)
    mongoc_bulkwriteopts_t *self;
    const bson_t *extra;
    CODE:
        mongoc_bulkwriteopts_set_extra(self, extra);

void
bulkwriteopts_set_serverid(self, serverid)
    mongoc_bulkwriteopts_t *self;
    uint32_t serverid;
    CODE:
        mongoc_bulkwriteopts_set_serverid(self, serverid);

void
bulkwriteopts_destroy(self)
    mongoc_bulkwriteopts_t *self;
    CODE:
        mongoc_bulkwriteopts_destroy(self);

int64_t
bulkwriteresult_insertedcount(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_insertedcount(self);
    OUTPUT:
        RETVAL

int64_t
bulkwriteresult_upsertedcount(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_upsertedcount(self);
    OUTPUT:
        RETVAL

int64_t
bulkwriteresult_matchedcount(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_matchedcount(self);
    OUTPUT:
        RETVAL

int64_t
bulkwriteresult_modifiedcount(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_modifiedcount(self);
    OUTPUT:
        RETVAL

int64_t
bulkwriteresult_deletedcount(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_deletedcount(self);
    OUTPUT:
        RETVAL

const bson_t *
bulkwriteresult_insertresults(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_insertresults(self);
    OUTPUT:
        RETVAL

const bson_t *
bulkwriteresult_updateresults(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_updateresults(self);
    OUTPUT:
        RETVAL

const bson_t *
bulkwriteresult_deleteresults(self)
    const mongoc_bulkwriteresult_t* self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_deleteresults(self);
    OUTPUT:
        RETVAL

uint32_t
bulkwriteresult_serverid(self)
    const mongoc_bulkwriteresult_t *self;
    CODE:
        RETVAL = mongoc_bulkwriteresult_serverid(self);
    OUTPUT:
        RETVAL

bool
bulkwriteexception_error(self, error)
    const mongoc_bulkwriteexception_t *self;
    bson_error_t* error;
    CODE:
        mongoc_bulkwriteexception_error(self, error);

const bson_t *
bulkwriteexception_writeerrors(self)
    const mongoc_bulkwriteexception_t *self;
    CODE:
        RETVAL = mongoc_bulkwriteexception_writeerrors(self);
    OUTPUT:
        RETVAL

const bson_t *
bulkwriteexception_writeconcernerrors(self)
    const mongoc_bulkwriteexception_t * self;
    CODE:
        RETVAL = mongoc_bulkwriteexception_writeconcernerrors(self);
    OUTPUT:
        RETVAL

const bson_t *
bulkwriteexception_errorreply(self)
    const mongoc_bulkwriteexception_t *self;
    CODE:
        RETVAL = mongoc_bulkwriteexception_errorreply(self);
    OUTPUT:
        RETVAL