自学教程：C++ BSON_ITER_HOLDS_INT32函数代码示例

/*************************************************************************************************************************F_SECUNDARIA: Obteniendo el VALOR dlong int IP, puerto o numBloque para una copiaX de un bloque X        TESTEADO =)****************************/long int getValorDeUnaCopia_ArchivoDB (const bson_t * documento_X, int numBloque, int numDeCopia, char * claveRequerida){    bson_iter_t punteroDeBusqueda;    bson_iter_t valorEncontrado;    long int valorRequerido;	// GENERO LA CLAVE DE BUSQUEDA	//Ejemplo "Bloqlong int.IP" 	Bloques.numBloque.ArrayDeCopias.numDeCopia.claveRequerida (clavlong int IP o puerto o numDeBloque)    char *claveGenerada = string_new();    	string_append(&claveGenerada, "Bloques");    		string_append(&claveGenerada, ".");		string_append(&claveGenerada, string_itoa(numBloque));			string_append(&claveGenerada, ".copias.");		string_append(&claveGenerada, string_itoa(numDeCopia-1));			string_append(&claveGenerada, ".");		string_append(&claveGenerada, claveRequerida);		if (documento_X != NULL &&		        bson_iter_init (&punteroDeBusqueda, documento_X) &&		        bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&		        BSON_ITER_HOLDS_INT32 (&valorEncontrado))		{        valorRequerido = bson_iter_int32 (&valorEncontrado);    }    free(claveGenerada);    return valorRequerido;}

//Devuelve un num positivo o Devuelve 0 si hay errorint getCantidadDeCopiasDe1Bloque_ArchivoDB(const bson_t * documento_X, int numBloque){    bson_iter_t punteroDeBusqueda;    bson_iter_t valorEncontrado;    int CantidadDeCopias = 0;    char *claveGenerada = string_new();		string_append(&claveGenerada, "Bloques");    		string_append(&claveGenerada, ".");		string_append(&claveGenerada, string_itoa(numBloque));			string_append(&claveGenerada, ".");		string_append(&claveGenerada, "cantidadDeCopias");    if (documento_X != NULL &&        bson_iter_init (&punteroDeBusqueda, documento_X) &&        bson_iter_find_descendant (&punteroDeBusqueda, claveGenerada, &valorEncontrado) &&        BSON_ITER_HOLDS_INT32 (&valorEncontrado))    {        CantidadDeCopias = bson_iter_int32 (&valorEncontrado);    }    free(claveGenerada);    return CantidadDeCopias;}

static voidtest_write_concern_bson_omits_defaults (void){   mongoc_write_concern_t *write_concern;   const bson_t *gle;   const bson_t *bson;   bson_iter_t iter;   write_concern = mongoc_write_concern_new();   /*    * Check generated bson.    */   ASSERT(write_concern);   gle = _mongoc_write_concern_get_gle(write_concern);   ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);   ASSERT(!bson_iter_init_find(&iter, gle, "fsync"));   ASSERT(!bson_iter_init_find(&iter, gle, "j"));   ASSERT(!bson_iter_init_find(&iter, gle, "w"));   ASSERT(gle);   bson = _mongoc_write_concern_get_bson(write_concern);   ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));   ASSERT(!bson_iter_init_find(&iter, bson, "fsync"));   ASSERT(!bson_iter_init_find(&iter, bson, "j"));   ASSERT(!bson_iter_init_find(&iter, gle, "w"));   ASSERT(bson);   mongoc_write_concern_destroy(write_concern);}

static voidtest_write_concern_bson_includes_false_fsync_and_journal (void){   mongoc_write_concern_t *write_concern;   const bson_t *gle;   const bson_t *bson;   bson_iter_t iter;   write_concern = mongoc_write_concern_new();   /*    * Check generated bson.    */   ASSERT(write_concern);   mongoc_write_concern_set_fsync(write_concern, false);   mongoc_write_concern_set_journal(write_concern, false);   gle = _mongoc_write_concern_get_gle(write_concern);   ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);   ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));   ASSERT(!bson_iter_init_find(&iter, gle, "w"));   ASSERT(gle);   bson = _mongoc_write_concern_get_bson(write_concern);   ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));   ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && !bson_iter_bool(&iter));   ASSERT(!bson_iter_init_find(&iter, bson, "w"));   ASSERT(bson);   mongoc_write_concern_destroy(write_concern);}

bool_mongoc_convert_validate_flags (mongoc_client_t *client,                                const bson_iter_t *iter,                                bson_validate_flags_t *flags,                                bson_error_t *error){   if (BSON_ITER_HOLDS_BOOL (iter)) {      if (!bson_iter_as_bool (iter)) {         *flags = BSON_VALIDATE_NONE;         return true;      } else {         /* validate: false is ok but validate: true is prohibited */         CONVERSION_ERR ("Invalid option /"%s/": true, must be a bitwise-OR of"                         " bson_validate_flags_t values.",                         bson_iter_key (iter));      }   } else if (BSON_ITER_HOLDS_INT32 (iter)) {      if (bson_iter_int32 (iter) <= 0x1F) {         *flags = (bson_validate_flags_t) bson_iter_int32 (iter);         return true;      } else {         CONVERSION_ERR ("Invalid field /"%s/" in opts, must be a bitwise-OR of"                         " bson_validate_flags_t values.",                         bson_iter_key (iter));      }   }   CONVERSION_ERR ("Invalid type for option /"%s/": /"%s/"."                   " /"%s/" must be a boolean or a bitwise-OR of"                   " bson_validate_flags_t values.",                   bson_iter_key (iter),                   _mongoc_bson_type_to_str (bson_iter_type (iter)),                   bson_iter_key (iter));}

boolmongoc_uri_set_option_as_int32 (mongoc_uri_t *uri,                                const char   *option,                                int32_t       value){   const bson_t *options;   bson_iter_t iter;   BSON_ASSERT (option);   if (!mongoc_uri_option_is_int32 (option)) {      return false;   }   if ((options = mongoc_uri_get_options (uri)) &&         bson_iter_init_find_case (&iter, options, option)) {      if (BSON_ITER_HOLDS_INT32 (&iter)) {         bson_iter_overwrite_int32 (&iter, value);         return true;      } else {         return false;      }   }   bson_append_int32(&uri->options, option, -1, value);   return true;}

static voidtest_bson_iter_overwrite_int32 (void){   bson_iter_t iter;   bson_t b;   bson_init(&b);   assert(bson_append_int32(&b, "key", -1, 1234));   assert(bson_iter_init_find(&iter, &b, "key"));   assert(BSON_ITER_HOLDS_INT32(&iter));   bson_iter_overwrite_int32(&iter, 4321);   assert(bson_iter_init_find(&iter, &b, "key"));   assert(BSON_ITER_HOLDS_INT32(&iter));   assert_cmpint(bson_iter_int32(&iter), ==, 4321);   bson_destroy(&b);}

static void_mongoc_cursor_populate_error (mongoc_cursor_t *cursor,                               const bson_t    *doc,                               bson_error_t    *error){   bson_uint32_t code = MONGOC_ERROR_QUERY_FAILURE;   bson_iter_t iter;   const char *msg = "Unknown query failure";   BSON_ASSERT (cursor);   BSON_ASSERT (doc);   BSON_ASSERT (error);   if (bson_iter_init_find (&iter, doc, "code") &&       BSON_ITER_HOLDS_INT32 (&iter)) {      code = bson_iter_int32 (&iter);   }   if (bson_iter_init_find (&iter, doc, "$err") &&       BSON_ITER_HOLDS_UTF8 (&iter)) {      msg = bson_iter_utf8 (&iter, NULL);   }   if (cursor->is_command &&       bson_iter_init_find (&iter, doc, "errmsg") &&       BSON_ITER_HOLDS_UTF8 (&iter)) {      msg = bson_iter_utf8 (&iter, NULL);   }   bson_set_error(error, MONGOC_ERROR_QUERY, code, "%s", msg);}

static voidtest_write_concern_basic (void){    mongoc_write_concern_t *write_concern;    const bson_t *b;    bson_iter_t iter;    write_concern = mongoc_write_concern_new();    /*     * Test defaults.     */    assert(write_concern);    assert(!mongoc_write_concern_get_fsync(write_concern));    assert(!mongoc_write_concern_get_journal(write_concern));    assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);    assert(!mongoc_write_concern_get_wtimeout(write_concern));    assert(!mongoc_write_concern_get_wmajority(write_concern));    mongoc_write_concern_set_fsync(write_concern, TRUE);    assert(mongoc_write_concern_get_fsync(write_concern));    mongoc_write_concern_set_fsync(write_concern, FALSE);    assert(!mongoc_write_concern_get_fsync(write_concern));    mongoc_write_concern_set_journal(write_concern, TRUE);    assert(mongoc_write_concern_get_journal(write_concern));    mongoc_write_concern_set_journal(write_concern, FALSE);    assert(!mongoc_write_concern_get_journal(write_concern));    /*     * Test changes to w.     */    mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);    assert(mongoc_write_concern_get_wmajority(write_concern));    mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);    assert(!mongoc_write_concern_get_wmajority(write_concern));    mongoc_write_concern_set_wmajority(write_concern, 1000);    assert(mongoc_write_concern_get_wmajority(write_concern));    assert(mongoc_write_concern_get_wtimeout(write_concern) == 1000);    mongoc_write_concern_set_wtimeout(write_concern, 0);    assert(!mongoc_write_concern_get_wtimeout(write_concern));    mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);    assert(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);    mongoc_write_concern_set_w(write_concern, 3);    assert(mongoc_write_concern_get_w(write_concern) == 3);    /*     * Check generated bson.     */    mongoc_write_concern_set_fsync(write_concern, TRUE);    mongoc_write_concern_set_journal(write_concern, TRUE);    b = _mongoc_write_concern_freeze(write_concern);    assert(bson_iter_init_find(&iter, b, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));    assert(bson_iter_init_find(&iter, b, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));    assert(bson_iter_init_find(&iter, b, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);    assert(b);    mongoc_write_concern_destroy(write_concern);}

static int mongo_get_oauth_key(const u08bits *kid, oauth_key_data_raw *key) {	mongoc_collection_t * collection = mongo_get_collection("oauth_key");	if (!collection)		return -1;	bson_t query;	bson_init(&query);	BSON_APPEND_UTF8(&query, "kid", (const char *)kid);	bson_t fields;	bson_init(&fields);	BSON_APPEND_INT32(&fields, "lifetime", 1);	BSON_APPEND_INT32(&fields, "timestamp", 1);	BSON_APPEND_INT32(&fields, "as_rs_alg", 1);	BSON_APPEND_INT32(&fields, "ikm_key", 1);	mongoc_cursor_t * cursor;	cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 1, 0,			&query, &fields, NULL);	int ret = -1;	ns_bzero(key,sizeof(oauth_key_data_raw));	STRCPY(key->kid,kid);	if (!cursor) {		TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR,				"Error querying MongoDB collection 'oauth_key'/n");	} else {		const bson_t * item;		uint32_t length;		bson_iter_t iter;		if (mongoc_cursor_next(cursor, &item)) {			if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "as_rs_alg") && BSON_ITER_HOLDS_UTF8(&iter)) {				STRCPY(key->as_rs_alg,bson_iter_utf8(&iter, &length));			}			if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "ikm_key") && BSON_ITER_HOLDS_UTF8(&iter)) {				STRCPY(key->ikm_key,bson_iter_utf8(&iter, &length));			}			if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "timestamp") && BSON_ITER_HOLDS_INT64(&iter)) {				key->timestamp = (u64bits)bson_iter_int64(&iter);			}			if (bson_iter_init(&iter, item) && bson_iter_find(&iter, "lifetime") && BSON_ITER_HOLDS_INT32(&iter)) {				key->lifetime = (u32bits)bson_iter_int32(&iter);			}			ret = 0;		}		mongoc_cursor_destroy(cursor);	}	mongoc_collection_destroy(collection);	bson_destroy(&query);	bson_destroy(&fields);	return ret;}

mongoc_client_pool_t *mongoc_client_pool_new (const mongoc_uri_t *uri){   mongoc_topology_t *topology;   mongoc_client_pool_t *pool;   const bson_t *b;   bson_iter_t iter;   ENTRY;   BSON_ASSERT (uri);   pool = (mongoc_client_pool_t *)bson_malloc0(sizeof *pool);   mongoc_mutex_init(&pool->mutex);   _mongoc_queue_init(&pool->queue);   pool->uri = mongoc_uri_copy(uri);   pool->min_pool_size = 0;   pool->max_pool_size = 100;   pool->size = 0;   topology = mongoc_topology_new(uri, false);   pool->topology = topology;   b = mongoc_uri_get_options(pool->uri);   if (bson_iter_init_find_case(&iter, b, "minpoolsize")) {      if (BSON_ITER_HOLDS_INT32(&iter)) {         pool->min_pool_size = BSON_MAX(0, bson_iter_int32(&iter));      }   }   if (bson_iter_init_find_case(&iter, b, "maxpoolsize")) {      if (BSON_ITER_HOLDS_INT32(&iter)) {         pool->max_pool_size = BSON_MAX(1, bson_iter_int32(&iter));      }   }   mongoc_counter_client_pools_active_inc();   RETURN(pool);}

int database_find_blockchain_transaction(struct database* db, unsigned char* hash, size_t max_height, struct transaction** tx, size_t* height){    mongoc_collection_t* collection = mongoc_client_get_collection(db->client, database_name(db), "transactions");    // Build a query doc    bson_t* query = bson_new();    // Set the hash    BSON_APPEND_BINARY(query, "hash", BSON_SUBTYPE_BINARY, (uint8_t*)hash, 32);    // Force the height to be valid (on the main chain)    bson_t* height_doc = bson_new();    BSON_APPEND_DOCUMENT_BEGIN(query, "height", height_doc);    BSON_APPEND_INT32(height_doc, "$lte", (int)max_height);    BSON_APPEND_INT32(height_doc, "$gte", 0);    bson_append_document_end(query, height_doc);    // Perform find    mongoc_cursor_t* cursor = mongoc_collection_find(collection, MONGOC_QUERY_NONE, 0, 0, 0, query, NULL, NULL);    bson_error_t error;    if(cursor == NULL || mongoc_cursor_error(cursor, &error)) {        printf("MongoDB error: %s/n", (cursor == NULL) ? "NULL cursor" : error.message);        return -1;    }    bson_t const* doc;    int found = 0;    while(mongoc_cursor_next(cursor, &doc) != 0) {        if(height != NULL) {            bson_iter_t iter;            if(!bson_iter_init_find(&iter, doc, "height") || !BSON_ITER_HOLDS_INT32(&iter)) {                printf("MongoDB error: tx doesn't have height!/n");                return -1;            }            *height = (size_t)bson_iter_int32(&iter);        }        if(tx != NULL) {            *tx = transaction_from_bson(doc);        }        found = 1;        break;    }    mongoc_cursor_destroy(cursor);    bson_destroy(height_doc);    bson_destroy(query);    mongoc_collection_destroy(collection);    return found;}

static voidtest_bson_iter_mixed (void){   bson_iter_t iter;   bson_decimal128_t iter_value;   bson_decimal128_t value;   bson_t *b;   bson_t *b2;   b = bson_new();   b2 = bson_new();   value.high = 0;   value.low = 1;   assert(bson_append_utf8(b2, "foo", -1, "bar", -1));   assert(bson_append_code(b, "0", -1, "var a = {};"));   assert(bson_append_code_with_scope(b, "1", -1, "var b = {};", b2));   assert(bson_append_int32(b, "2", -1, 1234));   assert(bson_append_int64(b, "3", -1, 4567));   assert(bson_append_time_t(b, "4", -1, 123456));   assert(bson_append_decimal128(b, "5", -1, &value));   assert(bson_iter_init(&iter, b));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_CODE(&iter));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_CODEWSCOPE(&iter));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_INT32(&iter));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_INT64(&iter));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_DATE_TIME(&iter));   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_DECIMAL128(&iter));   assert(!bson_iter_next(&iter));   assert(bson_iter_init_find(&iter, b, "3"));   assert(!strcmp(bson_iter_key(&iter), "3"));   assert(bson_iter_int64(&iter) == 4567);   assert(bson_iter_next(&iter));   assert(BSON_ITER_HOLDS_DATE_TIME(&iter));   assert(bson_iter_time_t(&iter) == 123456);   assert(bson_iter_date_time(&iter) == 123456000);   assert(bson_iter_next(&iter));   /* This test uses memcmp because libbson lacks decimal128 comparison. */   bson_iter_decimal128(&iter, &iter_value);   assert(memcmp(&iter_value, &value, sizeof(value)) == 0);   assert(!bson_iter_next(&iter));   bson_destroy(b);   bson_destroy(b2);}

static gbooleansim_parser_connect_id (bson_iter_t *piter, const char *key, SimCommand *cmd){  g_return_val_if_fail (piter != NULL, FALSE);  g_return_val_if_fail (cmd != NULL, FALSE);  g_return_val_if_fail (key != NULL, FALSE);  gboolean result = FALSE;  if (BSON_ITER_HOLDS_INT32(piter))  {    cmd->id = bson_iter_int32(piter);    result = TRUE;   }   return result;}

/*************************************************************************************************************************F_SECUNDARIA: Obteniendo CANTIDAD TOTAL DE BLOQUES que conforman un Archivo 								   TESTEADO =)****************************/int getCantidadTotalDeBloques_ArchivoDB(const bson_t * documento_X)//Devuelve un num positivo o Devuelve 0 si hay error{    bson_iter_t punteroDeBusqueda;    bson_iter_t valorEncontrado;    int CantidadBloques = 0;    if (documento_X != NULL &&        bson_iter_init (&punteroDeBusqueda, documento_X) &&        bson_iter_find_descendant (&punteroDeBusqueda, "cantidadDeBloques", &valorEncontrado) &&        BSON_ITER_HOLDS_INT32 (&valorEncontrado))    {        CantidadBloques = bson_iter_int32 (&valorEncontrado);    }    return CantidadBloques;}

static gbooleansim_parser_connect_type (bson_iter_t *piter, const char *key, SimCommand *cmd){  g_return_val_if_fail (piter != NULL, FALSE);  g_return_val_if_fail (cmd != NULL, FALSE);  g_return_val_if_fail (key != NULL, FALSE);  gboolean result = FALSE;  if (BSON_ITER_HOLDS_INT32(piter))  {    cmd->data.connect.type = bson_iter_int32 (piter);    if (sim_parse_check_session_type (cmd->data.connect.type))      result = TRUE;    else      g_message ("Bad BSON connect message (type)");  }   return result;}

int32_tmongoc_uri_get_option_as_int32(const mongoc_uri_t *uri, const char *option,                               int32_t fallback){   const bson_t *options;   bson_iter_t iter;   int32_t retval = fallback;   if ((options = mongoc_uri_get_options (uri)) &&        bson_iter_init_find_case (&iter, options, option) &&        BSON_ITER_HOLDS_INT32 (&iter)) {      if (!(retval = bson_iter_int32(&iter))) {         retval = fallback;      }   }   return retval;}

SEXP ConvertValue(bson_iter_t* iter){  if(BSON_ITER_HOLDS_INT32(iter)){    return ScalarInteger(bson_iter_int32(iter));  } else if(BSON_ITER_HOLDS_NULL(iter)){    return R_NilValue;  } else if(BSON_ITER_HOLDS_BOOL(iter)){    return ScalarLogical(bson_iter_bool(iter));  } else if(BSON_ITER_HOLDS_DOUBLE(iter)){    return ScalarReal(bson_iter_double(iter));  } else if(BSON_ITER_HOLDS_INT64(iter)){    return ScalarReal((double) bson_iter_int64(iter));  } else if(BSON_ITER_HOLDS_UTF8(iter)){    return mkStringUTF8(bson_iter_utf8(iter, NULL));  } else if(BSON_ITER_HOLDS_CODE(iter)){    return mkStringUTF8(bson_iter_code(iter, NULL));  } else if(BSON_ITER_HOLDS_BINARY(iter)){    return ConvertBinary(iter);  } else if(BSON_ITER_HOLDS_DATE_TIME(iter)){    return ConvertDate(iter);  } else if(BSON_ITER_HOLDS_OID(iter)){    const bson_oid_t *val = bson_iter_oid(iter);    char str[25];    bson_oid_to_string(val, str);    return mkString(str);  } else if(BSON_ITER_HOLDS_ARRAY(iter)){    bson_iter_t child1;    bson_iter_t child2;    bson_iter_recurse (iter, &child1);    bson_iter_recurse (iter, &child2);    return ConvertArray(&child1, &child2);  } else if(BSON_ITER_HOLDS_DOCUMENT(iter)){    bson_iter_t child1;    bson_iter_t child2;    bson_iter_recurse (iter, &child1);    bson_iter_recurse (iter, &child2);    return ConvertObject(&child1, &child2);  } else {    stop("Unimplemented BSON type %d/n", bson_iter_type(iter));  }}

static void_bson_to_error (const bson_t *b,                bson_error_t *error){   bson_iter_t iter;   int code = 0;   BSON_ASSERT(b);   if (!error) {      return;   }   if (bson_iter_init_find(&iter, b, "code") && BSON_ITER_HOLDS_INT32(&iter)) {      code = bson_iter_int32(&iter);   }   if (bson_iter_init_find(&iter, b, "$err") && BSON_ITER_HOLDS_UTF8(&iter)) {      bson_set_error(error,                     MONGOC_ERROR_QUERY,                     code,                     "%s",                     bson_iter_utf8(&iter, NULL));      return;   }   if (bson_iter_init_find(&iter, b, "errmsg") && BSON_ITER_HOLDS_UTF8(&iter)) {      bson_set_error(error,                     MONGOC_ERROR_QUERY,                     code,                     "%s",                     bson_iter_utf8(&iter, NULL));      return;   }   bson_set_error(error,                  MONGOC_ERROR_QUERY,                  MONGOC_ERROR_QUERY_FAILURE,                  "An unknown error ocurred on the server.");}

SEXP ConvertValue(bson_iter_t* iter){  if(BSON_ITER_HOLDS_INT32(iter)){    return ScalarInteger(bson_iter_int32(iter));  } else if(BSON_ITER_HOLDS_NULL(iter)){    return R_NilValue;  } else if(BSON_ITER_HOLDS_BOOL(iter)){    return ScalarLogical(bson_iter_bool(iter));  } else if(BSON_ITER_HOLDS_DOUBLE(iter)){    return ScalarReal(bson_iter_double(iter));  } else if(BSON_ITER_HOLDS_INT64(iter)){    return ScalarReal((double) bson_iter_int64(iter));  } else if(BSON_ITER_HOLDS_UTF8(iter)){    return mkStringUTF8(bson_iter_utf8(iter, NULL));  } else if(BSON_ITER_HOLDS_CODE(iter)){    return mkStringUTF8(bson_iter_code(iter, NULL));  } else if(BSON_ITER_HOLDS_BINARY(iter)){    return ConvertBinary(iter);  } else if(BSON_ITER_HOLDS_DATE_TIME(iter)){    return ConvertDate(iter);  } else if(BSON_ITER_HOLDS_OID(iter)){    //not sure if this casting works    return mkRaw((unsigned char *) bson_iter_oid(iter), 12);  } else if(BSON_ITER_HOLDS_ARRAY(iter)){    bson_iter_t child1;    bson_iter_t child2;    bson_iter_recurse (iter, &child1);    bson_iter_recurse (iter, &child2);    return ConvertArray(&child1, &child2);  } else if(BSON_ITER_HOLDS_DOCUMENT(iter)){    bson_iter_t child1;    bson_iter_t child2;    bson_iter_recurse (iter, &child1);    bson_iter_recurse (iter, &child2);    return ConvertObject(&child1, &child2);  } else {    stop("Unimplemented BSON type %d/n", bson_iter_type(iter));  }}

static mongoc_stream_t *mongoc_client_connect_tcp (const mongoc_uri_t       *uri,                           const mongoc_host_list_t *host,                           bson_error_t             *error){   mongoc_socket_t *sock = NULL;   struct addrinfo hints;   struct addrinfo *result, *rp;   int32_t connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;   int64_t expire_at;   const bson_t *options;   bson_iter_t iter;   char portstr [8];   int s;   ENTRY;   bson_return_val_if_fail (uri, NULL);   bson_return_val_if_fail (host, NULL);   if ((options = mongoc_uri_get_options (uri)) &&       bson_iter_init_find (&iter, options, "connecttimeoutms") &&       BSON_ITER_HOLDS_INT32 (&iter)) {      if (!(connecttimeoutms = bson_iter_int32(&iter))) {         connecttimeoutms = MONGOC_DEFAULT_CONNECTTIMEOUTMS;      }   }   BSON_ASSERT (connecttimeoutms);   expire_at = bson_get_monotonic_time () + (connecttimeoutms * 1000L);   bson_snprintf (portstr, sizeof portstr, "%hu", host->port);   memset (&hints, 0, sizeof hints);   hints.ai_family = host->family;   hints.ai_socktype = SOCK_STREAM;   hints.ai_flags = 0;   hints.ai_protocol = 0;   s = getaddrinfo (host->host, portstr, &hints, &result);   if (s != 0) {      mongoc_counter_dns_failure_inc ();      bson_set_error(error,                     MONGOC_ERROR_STREAM,                     MONGOC_ERROR_STREAM_NAME_RESOLUTION,                     "Failed to resolve %s",                     host->host);      RETURN (NULL);   }   mongoc_counter_dns_success_inc ();   for (rp = result; rp; rp = rp->ai_next) {      /*       * Create a new non-blocking socket.       */      if (!(sock = mongoc_socket_new (rp->ai_family,                                      rp->ai_socktype,                                      rp->ai_protocol))) {         continue;      }      /*       * Try to connect to the peer.       */      if (0 != mongoc_socket_connect (sock,                                      rp->ai_addr,                                      (socklen_t)rp->ai_addrlen,                                      expire_at)) {         char errmsg_buf[32];         const char * errmsg;         errmsg = bson_strerror_r (mongoc_socket_errno (sock), errmsg_buf, sizeof errmsg_buf);         MONGOC_WARNING ("Failed to connect, error: %d, %s/n",                         mongoc_socket_errno(sock),                         errmsg);         mongoc_socket_destroy (sock);         sock = NULL;         continue;      }      break;   }   if (!sock) {      bson_set_error (error,                      MONGOC_ERROR_STREAM,                      MONGOC_ERROR_STREAM_CONNECT,                      "Failed to connect to target host: %s",                      host->host_and_port);      freeaddrinfo (result);      RETURN (NULL);   }   freeaddrinfo (result);   return mongoc_stream_socket_new (sock);}

//.........这里部分代码省略.........      BSON_ASSERT (data);      BSON_ASSERT (len >= 5);      if (len > max_bson_obj_size) {         /* document is too large */         bson_t write_err_doc = BSON_INITIALIZER;         too_large_error (error, idx, len,                          max_bson_obj_size, &write_err_doc);         _mongoc_write_result_merge_legacy (            result, command, &write_err_doc,            MONGOC_ERROR_COLLECTION_INSERT_FAILED, offset + idx);         bson_destroy (&write_err_doc);         if (command->flags.ordered) {            /* send the batch so far (if any) and return the error */            break;         }      } else if ((n_docs_in_batch == 1 && singly) || size > (max_msg_size - len)) {         /* batch is full, send it and then start the next batch */         has_more = true;         break;      } else {         /* add document to batch and continue building the batch */         iov[n_docs_in_batch].iov_base = (void *) data;         iov[n_docs_in_batch].iov_len = len;         size += len;         n_docs_in_batch++;      }      idx++;   } while (bson_iter_next (&iter));   if (n_docs_in_batch) {      rpc.insert.msg_len = 0;      rpc.insert.request_id = 0;      rpc.insert.response_to = 0;      rpc.insert.opcode = MONGOC_OPCODE_INSERT;      rpc.insert.flags = (         (command->flags.ordered) ? MONGOC_INSERT_NONE                          : MONGOC_INSERT_CONTINUE_ON_ERROR);      rpc.insert.collection = ns;      rpc.insert.documents = iov;      rpc.insert.n_documents = n_docs_in_batch;      if (!mongoc_cluster_sendv_to_server (&client->cluster,                                           &rpc, 1, server_stream,                                           write_concern, error)) {         result->failed = true;         GOTO (cleanup);      }      if (_mongoc_write_concern_needs_gle (write_concern)) {         bool err = false;         bson_iter_t citer;         if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {            result->failed = true;            GOTO (cleanup);         }         err = (bson_iter_init_find (&citer, gle, "err")                && bson_iter_as_bool (&citer));         /*          * Overwrite the "n" field since it will be zero. Otherwise, our          * merge_legacy code will not know how many we tried in this batch.          */         if (!err &&             bson_iter_init_find (&citer, gle, "n") &&             BSON_ITER_HOLDS_INT32 (&citer) &&             !bson_iter_int32 (&citer)) {            bson_iter_overwrite_int32 (&citer, n_docs_in_batch);         }      }   }cleanup:   if (gle) {      _mongoc_write_result_merge_legacy (         result, command, gle, MONGOC_ERROR_COLLECTION_INSERT_FAILED,         current_offset);      current_offset = offset + idx;      bson_destroy (gle);      gle = NULL;   }   if (has_more) {      GOTO (again);   }   bson_free (iov);   EXIT;}

static voidtest_write_concern_basic (void){   mongoc_write_concern_t *write_concern;   const bson_t *gle;   const bson_t *bson;   bson_iter_t iter;   write_concern = mongoc_write_concern_new();BEGIN_IGNORE_DEPRECATIONS;   /*    * Test defaults.    */   ASSERT(write_concern);   ASSERT(!mongoc_write_concern_get_fsync(write_concern));   ASSERT(!mongoc_write_concern_get_journal(write_concern));   ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);   ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));   ASSERT(!mongoc_write_concern_get_wmajority(write_concern));   mongoc_write_concern_set_fsync(write_concern, true);   ASSERT(mongoc_write_concern_get_fsync(write_concern));   mongoc_write_concern_set_fsync(write_concern, false);   ASSERT(!mongoc_write_concern_get_fsync(write_concern));   mongoc_write_concern_set_journal(write_concern, true);   ASSERT(mongoc_write_concern_get_journal(write_concern));   mongoc_write_concern_set_journal(write_concern, false);   ASSERT(!mongoc_write_concern_get_journal(write_concern));   /*    * Test changes to w.    */   mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_MAJORITY);   ASSERT(mongoc_write_concern_get_wmajority(write_concern));   mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);   ASSERT(!mongoc_write_concern_get_wmajority(write_concern));   mongoc_write_concern_set_wmajority(write_concern, 1000);   ASSERT(mongoc_write_concern_get_wmajority(write_concern));   ASSERT(mongoc_write_concern_get_wtimeout(write_concern) == 1000);   mongoc_write_concern_set_wtimeout(write_concern, 0);   ASSERT(!mongoc_write_concern_get_wtimeout(write_concern));   mongoc_write_concern_set_w(write_concern, MONGOC_WRITE_CONCERN_W_DEFAULT);   ASSERT(mongoc_write_concern_get_w(write_concern) == MONGOC_WRITE_CONCERN_W_DEFAULT);   mongoc_write_concern_set_w(write_concern, 3);   ASSERT(mongoc_write_concern_get_w(write_concern) == 3);   /*    * Check generated bson.    */   mongoc_write_concern_set_fsync(write_concern, true);   mongoc_write_concern_set_journal(write_concern, true);   gle = _mongoc_write_concern_get_gle(write_concern);   ASSERT(bson_iter_init_find(&iter, gle, "getlasterror") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 1);   ASSERT(bson_iter_init_find(&iter, gle, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, gle, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, gle, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);   ASSERT(gle);   bson = _mongoc_write_concern_get_bson(write_concern);   ASSERT(!bson_iter_init_find(&iter, bson, "getlasterror"));   ASSERT(bson_iter_init_find(&iter, bson, "fsync") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, bson, "j") && BSON_ITER_HOLDS_BOOL(&iter) && bson_iter_bool(&iter));   ASSERT(bson_iter_init_find(&iter, bson, "w") && BSON_ITER_HOLDS_INT32(&iter) && bson_iter_int32(&iter) == 3);   ASSERT(bson);   mongoc_write_concern_destroy(write_concern);END_IGNORE_DEPRECATIONS;}

//.........这里部分代码省略.........                         MONGOC_ERROR_BSON,                         MONGOC_ERROR_BSON_INVALID,                         "updates is malformed.");         EXIT;      }   }   bson_snprintf (ns, sizeof ns, "%s.%s", database, collection);   bson_iter_init (&iter, command->documents);   while (bson_iter_next (&iter)) {      rpc.update.msg_len = 0;      rpc.update.request_id = 0;      rpc.update.response_to = 0;      rpc.update.opcode = MONGOC_OPCODE_UPDATE;      rpc.update.zero = 0;      rpc.update.collection = ns;      rpc.update.flags = MONGOC_UPDATE_NONE;      has_update = false;      has_selector = false;      is_upsert = false;      bson_iter_recurse (&iter, &subiter);      while (bson_iter_next (&subiter)) {         if (strcmp (bson_iter_key (&subiter), "u") == 0) {            bson_iter_document (&subiter, &len, &data);            rpc.update.update = data;            bson_init_static (&update, data, len);            has_update = true;         } else if (strcmp (bson_iter_key (&subiter), "q") == 0) {            bson_iter_document (&subiter, &len, &data);            rpc.update.selector = data;            bson_init_static (&selector, data, len);            has_selector = true;         } else if (strcmp (bson_iter_key (&subiter), "multi") == 0) {            val = bson_iter_bool (&subiter);            if (val) {               rpc.update.flags = (mongoc_update_flags_t)(                     rpc.update.flags | MONGOC_UPDATE_MULTI_UPDATE);            }         } else if (strcmp (bson_iter_key (&subiter), "upsert") == 0) {            val = bson_iter_bool (&subiter);            if (val) {               rpc.update.flags = (mongoc_update_flags_t)(                     rpc.update.flags | MONGOC_UPDATE_UPSERT);            }            is_upsert = true;         }      }      if (!mongoc_cluster_sendv_to_server (&client->cluster,                                           &rpc, 1, server_stream,                                           write_concern, error)) {         result->failed = true;         EXIT;      }      if (_mongoc_write_concern_needs_gle (write_concern)) {         if (!_mongoc_client_recv_gle (client, server_stream, &gle, error)) {            result->failed = true;            EXIT;         }         if (bson_iter_init_find (&subiter, gle, "n") &&             BSON_ITER_HOLDS_INT32 (&subiter)) {            affected = bson_iter_int32 (&subiter);         }         /*          * CDRIVER-372:          *          * Versions of MongoDB before 2.6 don't return the _id for an          * upsert if _id is not an ObjectId.          */         if (is_upsert &&             affected &&             !bson_iter_init_find (&subiter, gle, "upserted") &&             bson_iter_init_find (&subiter, gle, "updatedExisting") &&             BSON_ITER_HOLDS_BOOL (&subiter) &&             !bson_iter_bool (&subiter)) {            if (has_update && bson_iter_init_find (&subiter, &update, "_id")) {               _ignore_value (bson_append_iter (gle, "upserted", 8, &subiter));            } else if (has_selector &&                       bson_iter_init_find (&subiter, &selector, "_id")) {               _ignore_value (bson_append_iter (gle, "upserted", 8, &subiter));            }         }         _mongoc_write_result_merge_legacy (            result, command, gle,            MONGOC_ERROR_COLLECTION_UPDATE_FAILED, offset);         offset++;         bson_destroy (gle);      }   }   EXIT;}

mongoc_collection_t *mongoc_database_create_collection (mongoc_database_t *database,                                   const char        *name,                                   const bson_t      *options,                                   bson_error_t      *error){   mongoc_collection_t *collection = NULL;   bson_iter_t iter;   bson_t cmd;   bool capped = false;   bson_return_val_if_fail (database, NULL);   bson_return_val_if_fail (name, NULL);   if (strchr (name, '$')) {      bson_set_error (error,                      MONGOC_ERROR_NAMESPACE,                      MONGOC_ERROR_NAMESPACE_INVALID,                      "The namespace /"%s/" is invalid.",                      name);      return NULL;   }   if (options) {      if (bson_iter_init_find (&iter, options, "capped")) {         if (!BSON_ITER_HOLDS_BOOL (&iter)) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The argument /"capped/" must be a boolean.");            return NULL;         }         capped = bson_iter_bool (&iter);      }      if (bson_iter_init_find (&iter, options, "autoIndexId") &&          !BSON_ITER_HOLDS_BOOL (&iter)) {         bson_set_error (error,                         MONGOC_ERROR_COMMAND,                         MONGOC_ERROR_COMMAND_INVALID_ARG,                         "The argument /"autoIndexId/" must be a boolean.");         return NULL;      }      if (bson_iter_init_find (&iter, options, "size")) {         if (!BSON_ITER_HOLDS_INT32 (&iter) &&             !BSON_ITER_HOLDS_INT64 (&iter)) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The argument /"size/" must be an integer.");            return NULL;         }         if (!capped) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The /"size/" parameter requires {/"capped/": true}");            return NULL;         }      }      if (bson_iter_init_find (&iter, options, "max")) {         if (!BSON_ITER_HOLDS_INT32 (&iter) &&             !BSON_ITER_HOLDS_INT64 (&iter)) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The argument /"max/" must be an integer.");            return NULL;         }         if (!capped) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The /"size/" parameter requires {/"capped/": true}");            return NULL;         }      }      if (bson_iter_init_find (&iter, options, "storage")) {         if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {            bson_set_error (error,                            MONGOC_ERROR_COMMAND,                            MONGOC_ERROR_COMMAND_INVALID_ARG,                            "The /"storage/" parameter must be a document");            return NULL;         }         if (bson_iter_find (&iter, "wiredtiger")) {            if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {               bson_set_error (error,                               MONGOC_ERROR_COMMAND,                               MONGOC_ERROR_COMMAND_INVALID_ARG,                               "The /"wiredtiger/" option must take a document argument with a /"configString/" field");               return NULL;            }            if (bson_iter_find (&iter, "configString")) {//.........这里部分代码省略.........

void_mongoc_write_result_merge (mongoc_write_result_t *result,   /* IN */                            mongoc_write_command_t *command, /* IN */                            const bson_t *reply,             /* IN */                            uint32_t offset){   int32_t server_index = 0;   const bson_value_t *value;   bson_iter_t iter;   bson_iter_t citer;   bson_iter_t ar;   int32_t n_upserted = 0;   int32_t affected = 0;   ENTRY;   BSON_ASSERT (result);   BSON_ASSERT (reply);   if (bson_iter_init_find (&iter, reply, "n") &&       BSON_ITER_HOLDS_INT32 (&iter)) {      affected = bson_iter_int32 (&iter);   }   if (bson_iter_init_find (&iter, reply, "writeErrors") &&       BSON_ITER_HOLDS_ARRAY (&iter) && bson_iter_recurse (&iter, &citer) &&       bson_iter_next (&citer)) {      result->failed = true;   }   switch (command->type) {   case MONGOC_WRITE_COMMAND_INSERT:      result->nInserted += affected;      break;   case MONGOC_WRITE_COMMAND_DELETE:      result->nRemoved += affected;      break;   case MONGOC_WRITE_COMMAND_UPDATE:      /* server returns each upserted _id with its index into this batch       * look for "upserted": [{"index": 4, "_id": ObjectId()}, ...] */      if (bson_iter_init_find (&iter, reply, "upserted")) {         if (BSON_ITER_HOLDS_ARRAY (&iter) &&             (bson_iter_recurse (&iter, &ar))) {            while (bson_iter_next (&ar)) {               if (BSON_ITER_HOLDS_DOCUMENT (&ar) &&                   bson_iter_recurse (&ar, &citer) &&                   bson_iter_find (&citer, "index") &&                   BSON_ITER_HOLDS_INT32 (&citer)) {                  server_index = bson_iter_int32 (&citer);                  if (bson_iter_recurse (&ar, &citer) &&                      bson_iter_find (&citer, "_id")) {                     value = bson_iter_value (&citer);                     _mongoc_write_result_append_upsert (                        result, offset + server_index, value);                     n_upserted++;                  }               }            }         }         result->nUpserted += n_upserted;         /*          * XXX: The following addition to nMatched needs some checking.          *      I'm highly skeptical of it.          */         result->nMatched += BSON_MAX (0, (affected - n_upserted));      } else {         result->nMatched += affected;      }      if (bson_iter_init_find (&iter, reply, "nModified") &&          BSON_ITER_HOLDS_INT32 (&iter)) {         result->nModified += bson_iter_int32 (&iter);      }      break;   default:      BSON_ASSERT (false);      break;   }   if (bson_iter_init_find (&iter, reply, "writeErrors") &&       BSON_ITER_HOLDS_ARRAY (&iter)) {      _mongoc_write_result_merge_arrays (         offset, result, &result->writeErrors, &iter);   }   if (bson_iter_init_find (&iter, reply, "writeConcernError") &&       BSON_ITER_HOLDS_DOCUMENT (&iter)) {      uint32_t len;      const uint8_t *data;      bson_t write_concern_error;      char str[16];      const char *key;      /* writeConcernError is a subdocument in the server response       * append it to the result->writeConcernErrors array */      bson_iter_document (&iter, &len, &data);      bson_init_static (&write_concern_error, data, len);      bson_uint32_to_string (//.........这里部分代码省略.........

static voidtest_find_and_modify (void){   mongoc_collection_t *collection;   mongoc_client_t *client;   bson_error_t error;   bson_iter_t iter;   bson_iter_t citer;   bson_t *update;   bson_t doc = BSON_INITIALIZER;   bson_t reply;   mongoc_find_and_modify_opts_t *opts;   client = test_framework_client_new ();   ASSERT (client);   collection = get_test_collection (client, "test_find_and_modify");   ASSERT (collection);   BSON_APPEND_INT32 (&doc, "superduper", 77889);   ASSERT_OR_PRINT (mongoc_collection_insert (                       collection, MONGOC_INSERT_NONE, &doc, NULL, &error),                    error);   update = BCON_NEW ("$set", "{", "superduper", BCON_INT32 (1234), "}");   opts = mongoc_find_and_modify_opts_new ();   mongoc_find_and_modify_opts_set_update (opts, update);   mongoc_find_and_modify_opts_set_fields (opts,                                           tmp_bson ("{'superduper': 1}"));   mongoc_find_and_modify_opts_set_sort (opts, tmp_bson ("{'superduper': 1}"));   mongoc_find_and_modify_opts_set_flags (opts,                                          MONGOC_FIND_AND_MODIFY_RETURN_NEW);   ASSERT_OR_PRINT (mongoc_collection_find_and_modify_with_opts (                       collection, &doc, opts, &reply, &error),                    error);   assert (bson_iter_init_find (&iter, &reply, "value"));   assert (BSON_ITER_HOLDS_DOCUMENT (&iter));   assert (bson_iter_recurse (&iter, &citer));   assert (bson_iter_find (&citer, "superduper"));   assert (BSON_ITER_HOLDS_INT32 (&citer));   assert (bson_iter_int32 (&citer) == 1234);   assert (bson_iter_init_find (&iter, &reply, "lastErrorObject"));   assert (BSON_ITER_HOLDS_DOCUMENT (&iter));   assert (bson_iter_recurse (&iter, &citer));   assert (bson_iter_find (&citer, "updatedExisting"));   assert (BSON_ITER_HOLDS_BOOL (&citer));   assert (bson_iter_bool (&citer));   bson_destroy (&reply);   bson_destroy (update);   ASSERT_OR_PRINT (mongoc_collection_drop (collection, &error), error);   mongoc_find_and_modify_opts_destroy (opts);   mongoc_collection_destroy (collection);   mongoc_client_destroy (client);   bson_destroy (&doc);}

/** * _mongoc_gridfs_file_new_from_bson: * * creates a gridfs file from a bson object * * This is only really useful for instantiating a gridfs file from a server * side object */mongoc_gridfs_file_t *_mongoc_gridfs_file_new_from_bson (mongoc_gridfs_t *gridfs,                                   const bson_t    *data){   mongoc_gridfs_file_t *file;   const bson_value_t *value;   const char *key;   bson_iter_t iter;   const uint8_t *buf;   uint32_t buf_len;   ENTRY;   BSON_ASSERT (gridfs);   BSON_ASSERT (data);   file = (mongoc_gridfs_file_t *)bson_malloc0 (sizeof *file);   file->gridfs = gridfs;   bson_copy_to (data, &file->bson);   bson_iter_init (&iter, &file->bson);   while (bson_iter_next (&iter)) {      key = bson_iter_key (&iter);      if (0 == strcmp (key, "_id")) {         value = bson_iter_value (&iter);         bson_value_copy (value, &file->files_id);      } else if (0 == strcmp (key, "length")) {         if (!BSON_ITER_HOLDS_INT32 (&iter) &&             !BSON_ITER_HOLDS_INT64 (&iter) &&             !BSON_ITER_HOLDS_DOUBLE (&iter)) {            GOTO (failure);         }         file->length = bson_iter_as_int64 (&iter);      } else if (0 == strcmp (key, "chunkSize")) {         if (!BSON_ITER_HOLDS_INT32 (&iter) &&             !BSON_ITER_HOLDS_INT64 (&iter) &&             !BSON_ITER_HOLDS_DOUBLE (&iter)) {            GOTO (failure);         }         if (bson_iter_as_int64 (&iter) > INT32_MAX) {            GOTO (failure);         }         file->chunk_size = (int32_t)bson_iter_as_int64 (&iter);      } else if (0 == strcmp (key, "uploadDate")) {         if (!BSON_ITER_HOLDS_DATE_TIME (&iter)){            GOTO (failure);         }         file->upload_date = bson_iter_date_time (&iter);      } else if (0 == strcmp (key, "md5")) {         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {            GOTO (failure);         }         file->bson_md5 = bson_iter_utf8 (&iter, NULL);      } else if (0 == strcmp (key, "filename")) {         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {            GOTO (failure);         }         file->bson_filename = bson_iter_utf8 (&iter, NULL);      } else if (0 == strcmp (key, "contentType")) {         if (!BSON_ITER_HOLDS_UTF8 (&iter)) {            GOTO (failure);         }         file->bson_content_type = bson_iter_utf8 (&iter, NULL);      } else if (0 == strcmp (key, "aliases")) {         if (!BSON_ITER_HOLDS_ARRAY (&iter)) {            GOTO  (failure);         }         bson_iter_array (&iter, &buf_len, &buf);         bson_init_static (&file->bson_aliases, buf, buf_len);      } else if (0 == strcmp (key, "metadata")) {         if (!BSON_ITER_HOLDS_DOCUMENT (&iter)) {            GOTO (failure);         }         bson_iter_document (&iter, &buf_len, &buf);         bson_init_static (&file->bson_metadata, buf, buf_len);      }   }   /* TODO: is there are a minimal object we should be verifying that we    * actually have here? */   RETURN (file);failure:   bson_destroy (&file->bson);   RETURN (NULL);}