本文整理汇总了C++中bson_append_int32函数的典型用法代码示例。如果您正苦于以下问题:C++ bson_append_int32函数的具体用法?C++ bson_append_int32怎么用?C++ bson_append_int32使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了bson_append_int32函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: test_bson_copy_to_excluding
static void
test_bson_copy_to_excluding (void)
{
bson_iter_t iter;
bson_bool_t r;
bson_t b;
bson_t c;
int i;
bson_init(&b);
bson_append_int32(&b, "a", 1, 1);
bson_append_int32(&b, "b", 1, 2);
bson_copy_to_excluding(&b, &c, "b", NULL);
r = bson_iter_init_find(&iter, &c, "a");
assert(r);
r = bson_iter_init_find(&iter, &c, "b");
assert(!r);
i = bson_count_keys(&b);
assert_cmpint(i, ==, 2);
i = bson_count_keys(&c);
assert_cmpint(i, ==, 1);
bson_destroy(&b);
bson_destroy(&c);
}
示例2: handle_ismaster
static bool
handle_ismaster (mock_server_t *server,
mongoc_stream_t *client,
mongoc_rpc_t *rpc,
const bson_t *doc)
{
bson_t reply_doc = BSON_INITIALIZER;
time_t now = time (NULL);
BSON_ASSERT (server);
BSON_ASSERT (client);
BSON_ASSERT (rpc);
BSON_ASSERT (doc);
bson_append_bool (&reply_doc, "ismaster", -1, server->isMaster);
bson_append_int32 (&reply_doc, "maxBsonObjectSize", -1,
server->maxBsonObjectSize);
bson_append_int32 (&reply_doc, "maxMessageSizeBytes", -1,
server->maxMessageSizeBytes);
bson_append_int32 (&reply_doc, "minWireVersion", -1,
server->minWireVersion);
bson_append_int32 (&reply_doc, "maxWireVersion", -1,
server->maxWireVersion);
bson_append_double (&reply_doc, "ok", -1, 1.0);
bson_append_time_t (&reply_doc, "localtime", -1, now);
mock_server_reply_simple (server, client, rpc, MONGOC_REPLY_NONE, &reply_doc);
bson_destroy (&reply_doc);
return true;
}
示例3: test_bson_copy_to
static void
test_bson_copy_to (void)
{
bson_t b;
bson_t c;
int i;
/*
* Test inline structure copy.
*/
bson_init(&b);
assert(bson_append_int32(&b, "foobar", -1, 1234));
bson_copy_to(&b, &c);
assert_bson_equal(&b, &c);
bson_destroy(&c);
bson_destroy(&b);
/*
* Test malloced copy.
*/
bson_init(&b);
for (i = 0; i < 1000; i++) {
assert(bson_append_int32(&b, "foobar", -1, 1234));
}
bson_copy_to(&b, &c);
assert_bson_equal(&b, &c);
bson_destroy(&c);
bson_destroy(&b);
}
示例4: test_bson_iter_as_bool
static void
test_bson_iter_as_bool (void)
{
bson_iter_t iter;
bson_t b;
bson_init(&b);
bson_append_int32(&b, "int32[true]", -1, 1);
bson_append_int32(&b, "int32[false]", -1, 0);
bson_append_int64(&b, "int64[true]", -1, 1);
bson_append_int64(&b, "int64[false]", -1, 0);
bson_append_double(&b, "int64[true]", -1, 1.0);
bson_append_double(&b, "int64[false]", -1, 0.0);
bson_iter_init(&iter, &b);
bson_iter_next(&iter);
assert_cmpint(true, ==, bson_iter_as_bool(&iter));
bson_iter_next(&iter);
assert_cmpint(false, ==, bson_iter_as_bool(&iter));
bson_iter_next(&iter);
assert_cmpint(true, ==, bson_iter_as_bool(&iter));
bson_iter_next(&iter);
assert_cmpint(false, ==, bson_iter_as_bool(&iter));
bson_iter_next(&iter);
assert_cmpint(true, ==, bson_iter_as_bool(&iter));
bson_iter_next(&iter);
assert_cmpint(false, ==, bson_iter_as_bool(&iter));
bson_destroy(&b);
}
示例5: bson_pipeline_query1_create
bson_t * bson_pipeline_query1_create()
{
bson_t *bson_pipeline_query = bson_new();
bson_t *bson1, *bson2, *bson3, *bson4;
bson1 = bson_new();
bson2 = bson_new();
bson3 = bson_new();
bson_append_utf8(bson3, "_id", -1, "$action", -1);
bson4 = bson_new();
bson_append_int32(bson4, "$sum", -1, 1);
bson_append_document(bson3, "count", -1, bson4);
bson_append_document(bson2, "$group", -1, bson3);
bson_append_document(bson1, "0", -1, bson2);
bson2 = bson_new();
bson3 = bson_new();
bson_append_int32(bson3, "count", -1, -1);
bson_append_document(bson2, "$sort", -1, bson3);
bson_append_document(bson1, "1", -1, bson2);
bson_append_array(bson_pipeline_query, "pipeline", -1, bson1);
return bson_pipeline_query;
}
示例6: test_bson_document
void
test_bson_document (void)
{
bson *b, *e1, *e2;
e1 = bson_new ();
bson_append_int32 (e1, "i32", 1984);
bson_append_string (e1, "str", "hello world", -1);
bson_finish (e1);
e2 = bson_new ();
bson_append_string (e2, "foo", "bar", -1);
ok (bson_append_document (e2, "subd", e1),
"bson_append_document() works");
bson_finish (e2);
bson_free (e1);
b = bson_new ();
ok (bson_append_document (b, "doc", e2),
"bson_append_document() works still");
bson_finish (b);
bson_free (e2);
cmp_ok (bson_size (b), "==", 69, "BSON document element size check");
ok (memcmp (bson_data (b),
"\105\000\000\000\003\144\157\143\000\073\000\000\000\002\146"
"\157\157\000\004\000\000\000\142\141\162\000\003\163\165\142"
"\144\000\043\000\000\000\020\151\063\062\000\300\007\000\000"
"\002\163\164\162\000\014\000\000\000\150\145\154\154\157\040"
"\167\157\162\154\144\000\000\000\000",
bson_size (b)) == 0,
"BSON document element contents check");
bson_free (b);
e1 = bson_new ();
bson_append_int32 (e1, "foo", 42);
b = bson_new ();
ok (bson_append_document (b, "doc", e1) == FALSE,
"bson_append_document() with an unfinished document should fail");
bson_finish (e1);
ok (bson_append_document (b, NULL, e1) == FALSE,
"bson_append_document() with a NULL key should fail");
ok (bson_append_document (b, "doc", NULL) == FALSE,
"bson_append_document() with a NULL document should fail");
ok (bson_append_document (NULL, "doc", e1) == FALSE,
"bson_append_document() without a BSON object should fail");
bson_finish (b);
cmp_ok (bson_size (b), "==", 5,
"BSON object should be empty");
ok (bson_append_document (b, "doc", e1) == FALSE,
"Appending to a finished element should fail");
bson_free (e1);
bson_free (b);
}
示例7: main
int
main (int argc, char *argv[])
{
int i;
int n;
int bcon;
bson_t bson, foo, bar, baz;
bson_init (&bson);
if (argc != 3) {
fprintf (stderr,
"usage: bcon-speed NUM_ITERATIONS [y|n]\n"
"\n"
" y = perform speed tests with bcon\n"
" n = perform speed tests with bson_append\n"
"\n");
return EXIT_FAILURE;
}
assert (argc == 3);
n = atoi (argv[1]);
bcon = (argv[2][0] == 'y') ? 1 : 0;
for (i = 0; i < n; i++) {
if (bcon) {
BCON_APPEND (&bson,
"foo",
"{",
"bar",
"{",
"baz",
"[",
BCON_INT32 (1),
BCON_INT32 (2),
BCON_INT32 (3),
"]",
"}",
"}");
} else {
bson_append_document_begin (&bson, "foo", -1, &foo);
bson_append_document_begin (&foo, "bar", -1, &bar);
bson_append_array_begin (&bar, "baz", -1, &baz);
bson_append_int32 (&baz, "0", -1, 1);
bson_append_int32 (&baz, "1", -1, 2);
bson_append_int32 (&baz, "2", -1, 3);
bson_append_array_end (&bar, &baz);
bson_append_document_end (&foo, &bar);
bson_append_document_end (&bson, &foo);
}
bson_reinit (&bson);
}
bson_destroy (&bson);
return 0;
}
示例8: test_bson_array
void
test_bson_array (void)
{
bson *b, *e1, *e2;
e1 = bson_new ();
bson_append_int32 (e1, "0", 1984);
bson_append_string (e1, "1", "hello world", -1);
bson_finish (e1);
e2 = bson_new ();
bson_append_string (e2, "0", "bar", -1);
ok (bson_append_array (e2, "1", e1),
"bson_append_array() works");
bson_finish (e2);
bson_free (e1);
b = bson_new ();
ok (bson_append_array (b, "0", e2),
"bson_append_array() works still");
bson_finish (b);
bson_free (e2);
cmp_ok (bson_size (b), "==", 58, "BSON array element size check");
ok (memcmp (bson_data (b),
"\072\000\000\000\004\060\000\062\000\000\000\002\060\000\004"
"\000\000\000\142\141\162\000\004\061\000\037\000\000\000\020"
"\060\000\300\007\000\000\002\061\000\014\000\000\000\150\145"
"\154\154\157\040\167\157\162\154\144\000\000\000\000",
bson_size (b)) == 0,
"BSON array element contents check");
bson_free (b);
e1 = bson_new ();
bson_append_int32 (e1, "0", 1984);
b = bson_new ();
ok (bson_append_array (b, "array", e1) == FALSE,
"bson_append_array() with an unfinished array should fail");
bson_finish (e1);
ok (bson_append_array (b, NULL, e1) == FALSE,
"bson_append_array() with a NULL name should fail");
ok (bson_append_array (b, "foo", NULL) == FALSE,
"bson_append_array() with a NULL array should fail");
ok (bson_append_array (NULL, "foo", e1) == FALSE,
"bson_append_array() with a NULL BSON should fail");
bson_finish (b);
cmp_ok (bson_size (b), "==", 5,
"BSON object should be empty");
ok (bson_append_array (b, "array", e1) == FALSE,
"Appending to a finished element should fail");
bson_free (e1);
bson_free (b);
}
示例9: test_bson_as_json
static void
test_bson_as_json (void)
{
bson_oid_t oid;
bson_decimal128_t decimal128;
bson_t *b;
bson_t *b2;
char *str;
size_t len;
int i;
decimal128.high = 0x3040000000000000ULL;
decimal128.low = 0x000000000000000B;
bson_oid_init_from_string(&oid, "123412341234abcdabcdabcd");
b = bson_new();
assert(bson_append_utf8(b, "utf8", -1, "bar", -1));
assert(bson_append_int32(b, "int32", -1, 1234));
assert(bson_append_int64(b, "int64", -1, 4321));
assert(bson_append_double(b, "double", -1, 123.4));
assert(bson_append_undefined(b, "undefined", -1));
assert(bson_append_null(b, "null", -1));
assert(bson_append_oid(b, "oid", -1, &oid));
assert(bson_append_bool(b, "true", -1, true));
assert(bson_append_bool(b, "false", -1, false));
assert(bson_append_time_t(b, "date", -1, time(NULL)));
assert(bson_append_timestamp(b, "timestamp", -1, (uint32_t)time(NULL), 1234));
assert(bson_append_regex(b, "regex", -1, "^abcd", "xi"));
assert(bson_append_dbpointer(b, "dbpointer", -1, "mycollection", &oid));
assert(bson_append_minkey(b, "minkey", -1));
assert(bson_append_maxkey(b, "maxkey", -1));
assert(bson_append_symbol(b, "symbol", -1, "var a = {};", -1));
assert(bson_append_decimal128(b, "decimal128", -1, &decimal128));
b2 = bson_new();
assert(bson_append_int32(b2, "0", -1, 60));
assert(bson_append_document(b, "document", -1, b2));
assert(bson_append_array(b, "array", -1, b2));
{
const uint8_t binary[] = { 0, 1, 2, 3, 4 };
assert(bson_append_binary(b, "binary", -1, BSON_SUBTYPE_BINARY,
binary, sizeof binary));
}
for (i = 0; i < 1000; i++) {
str = bson_as_json(b, &len);
bson_free(str);
}
bson_destroy(b);
bson_destroy(b2);
}
示例10: test_bson_count_keys
static void
test_bson_count_keys (void)
{
bson_t b;
bson_init(&b);
assert(bson_append_int32(&b, "0", -1, 0));
assert(bson_append_int32(&b, "1", -1, 1));
assert(bson_append_int32(&b, "2", -1, 2));
assert_cmpint(bson_count_keys(&b), ==, 3);
bson_destroy(&b);
}
示例11: test_command
static void
test_command (void)
{
mongoc_database_t *database;
mongoc_client_t *client;
mongoc_cursor_t *cursor;
bson_error_t error;
const bson_t *doc;
bool r;
bson_t cmd = BSON_INITIALIZER;
bson_t reply;
client = mongoc_client_new (gTestUri);
assert (client);
database = mongoc_client_get_database (client, "admin");
/*
* Test a known working command, "ping".
*/
bson_append_int32 (&cmd, "ping", 4, 1);
cursor = mongoc_database_command (database, MONGOC_QUERY_NONE, 0, 1, 0, &cmd, NULL, NULL);
assert (cursor);
r = mongoc_cursor_next (cursor, &doc);
assert (r);
assert (doc);
r = mongoc_cursor_next (cursor, &doc);
assert (!r);
assert (!doc);
mongoc_cursor_destroy (cursor);
/*
* Test a non-existing command to ensure we get the failure.
*/
bson_reinit (&cmd);
bson_append_int32 (&cmd, "a_non_existing_command", -1, 1);
r = mongoc_database_command_simple (database, &cmd, NULL, &reply, &error);
assert (!r);
assert (error.domain == MONGOC_ERROR_QUERY);
assert (error.code == MONGOC_ERROR_QUERY_COMMAND_NOT_FOUND);
assert (!strcmp ("no such cmd: a_non_existing_command", error.message));
mongoc_database_destroy (database);
mongoc_client_destroy (client);
bson_destroy (&cmd);
}
示例12: test_bson_append_iter
static void
test_bson_append_iter (void)
{
bson_iter_t iter;
bson_bool_t r;
bson_t b;
bson_t c;
bson_init(&b);
bson_append_int32(&b, "a", 1, 1);
bson_append_int32(&b, "b", 1, 2);
bson_append_int32(&b, "c", 1, 3);
bson_append_utf8(&b, "d", 1, "hello", 5);
bson_init(&c);
r = bson_iter_init_find(&iter, &b, "a");
assert(r);
r = bson_append_iter(&c, NULL, 0, &iter);
assert(r);
r = bson_iter_init_find(&iter, &b, "c");
assert(r);
r = bson_append_iter(&c, NULL, 0, &iter);
assert(r);
r = bson_iter_init_find(&iter, &b, "d");
assert(r);
r = bson_append_iter(&c, "world", -1, &iter);
assert(r);
bson_iter_init(&iter, &c);
r = bson_iter_next(&iter);
assert(r);
assert_cmpstr("a", bson_iter_key(&iter));
assert_cmpint(BSON_TYPE_INT32, ==, bson_iter_type(&iter));
assert_cmpint(1, ==, bson_iter_int32(&iter));
r = bson_iter_next(&iter);
assert(r);
assert_cmpstr("c", bson_iter_key(&iter));
assert_cmpint(BSON_TYPE_INT32, ==, bson_iter_type(&iter));
assert_cmpint(3, ==, bson_iter_int32(&iter));
r = bson_iter_next(&iter);
assert(r);
assert_cmpint(BSON_TYPE_UTF8, ==, bson_iter_type(&iter));
assert_cmpstr("world", bson_iter_key(&iter));
assert_cmpstr("hello", bson_iter_utf8(&iter, NULL));
bson_destroy(&b);
bson_destroy(&c);
}
示例13: bson_pipeline_query4_create
bson_t * bson_pipeline_query4_create()
{
bson_t *bson_pipeline_query = bson_new();
bson_t *bson1, *bson2, *bson3, *bson4;
bson1 = bson_new();
bson2 = bson_new();
bson3 = bson_new();
bson_append_utf8(bson3, "modelName", -1, "movies", -1);
bson_append_document(bson2, "$match", -1, bson3);
bson_append_document(bson1, "0", -1, bson2);
bson2 = bson_new();
bson3 = bson_new();
bson_append_utf8(bson3, "action", -1, "Liked", -1);
bson_append_document(bson2, "$match", -1, bson3);
bson_append_document(bson1, "1", -1, bson2);
bson2 = bson_new();
bson3 = bson_new();
bson_append_utf8(bson3, "_id", -1, "$title", -1);
bson4 = bson_new();
bson_append_int32(bson4, "$sum", -1, 1);
bson_append_document(bson3, "count", -1, bson4);
bson_append_document(bson2, "$group", -1, bson3);
bson_append_document(bson1, "2", -1, bson2);
bson2 = bson_new();
bson3 = bson_new();
bson_append_int32(bson3, "count", -1, -1);
bson_append_document(bson2, "$sort", -1, bson3);
bson_append_document(bson1, "3", -1, bson2);
bson2 = bson_new();
bson_append_int32(bson2, "$limit", -1, 15);
bson_append_document(bson1, "4", -1, bson2);
bson_append_array(bson_pipeline_query, "pipeline", -1, bson1);
return bson_pipeline_query;
}
示例14: test_bson_append_int32
static void
test_bson_append_int32 (void)
{
bson_t *b;
bson_t *b2;
b = bson_new();
assert(bson_append_int32(b, "a", -1, -123));
assert(bson_append_int32(b, "c", -1, 0));
assert(bson_append_int32(b, "b", -1, 123));
b2 = get_bson("test33.bson");
assert_bson_equal(b, b2);
bson_destroy(b);
bson_destroy(b2);
}
示例15: mongoc_uri_parse_option
static bson_bool_t
mongoc_uri_parse_option (mongoc_uri_t *uri,
const char *str)
{
bson_int32_t v_int;
const char *end_key;
char *key;
char *value;
if (!(key = scan_to_unichar(str, '=', &end_key))) {
return FALSE;
}
value = strdup(end_key + 1);
mongoc_uri_do_unescape(&value);
if (!strcasecmp(key, "connecttimeoutms") ||
!strcasecmp(key, "sockettimeoutms") ||
!strcasecmp(key, "maxpoolsize") ||
!strcasecmp(key, "minpoolsize") ||
!strcasecmp(key, "maxidletimems") ||
!strcasecmp(key, "waitqueuemultiple") ||
!strcasecmp(key, "waitqueuetimeoutms") ||
!strcasecmp(key, "wtimeoutms")) {
v_int = strtol(value, NULL, 10);
bson_append_int32(&uri->options, key, -1, v_int);
} else if (!strcasecmp(key, "w")) {
if (*value == '-' || isdigit(*value)) {
v_int = strtol(value, NULL, 10);
bson_append_int32(&uri->options, key, -1, v_int);
} else {
bson_append_utf8(&uri->options, key, -1, value, -1);
}
} else if (!strcasecmp(key, "journal") ||
!strcasecmp(key, "slaveok") ||
!strcasecmp(key, "ssl")) {
bson_append_bool(&uri->options, key, -1, !strcmp(value, "true"));
} else if (!strcasecmp(key, "readpreferencetags")) {
mongoc_uri_parse_read_prefs(uri, value);
} else {
bson_append_utf8(&uri->options, key, -1, value, -1);
}
bson_free(key);
bson_free(value);
return TRUE;
}